1 /*
   2  * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /**
  25  * @test
  26  * @requires (vm.simpleArch == "x64" | vm.simpleArch == "sparcv9" | vm.simpleArch == "aarch64")
  27  * @library ../../../../../
  28  * @modules jdk.vm.ci/jdk.vm.ci.meta
  29  *          jdk.vm.ci/jdk.vm.ci.runtime
  30  *          java.base/jdk.internal.misc
  31  * @build jdk.vm.ci.runtime.test.TestResolvedJavaField
  32  * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI jdk.vm.ci.runtime.test.TestResolvedJavaField
  33  */
  34 
  35 package jdk.vm.ci.runtime.test;
  36 
  37 import jdk.vm.ci.meta.ResolvedJavaField;
  38 import jdk.vm.ci.meta.ResolvedJavaMethod;
  39 import org.junit.Test;
  40 
  41 import java.lang.annotation.Annotation;
  42 import java.lang.reflect.Field;
  43 import java.lang.reflect.Method;
  44 import java.util.Arrays;
  45 import java.util.HashSet;
  46 import java.util.Map;
  47 import java.util.Set;
  48 
  49 import static org.junit.Assert.assertArrayEquals;
  50 import static org.junit.Assert.assertEquals;
  51 import static org.junit.Assert.assertFalse;
  52 import static org.junit.Assert.assertTrue;
  53 
  54 /**
  55  * Tests for {@link ResolvedJavaField}.
  56  */
  57 public class TestResolvedJavaField extends FieldUniverse {
  58 
  59     public TestResolvedJavaField() {
  60     }
  61 
  62     @Test
  63     public void getModifiersTest() {
  64         for (Map.Entry<Field, ResolvedJavaField> e : fields.entrySet()) {
  65             int expected = e.getKey().getModifiers();
  66             int actual = e.getValue().getModifiers();
  67             assertEquals(expected, actual);
  68         }
  69     }
  70 
  71     @Test
  72     public void isSyntheticTest() {
  73         for (Map.Entry<Field, ResolvedJavaField> e : fields.entrySet()) {
  74             boolean expected = e.getKey().isSynthetic();
  75             boolean actual = e.getValue().isSynthetic();
  76             assertEquals(expected, actual);
  77         }
  78     }
  79 
  80     @Test
  81     public void getAnnotationsTest() {
  82         for (Map.Entry<Field, ResolvedJavaField> e : fields.entrySet()) {
  83             Annotation[] expected = e.getKey().getAnnotations();
  84             Annotation[] actual = e.getValue().getAnnotations();
  85             assertArrayEquals(expected, actual);
  86         }
  87     }
  88 
  89     @Test
  90     public void getAnnotationTest() {
  91         for (Map.Entry<Field, ResolvedJavaField> e : fields.entrySet()) {
  92             for (Annotation expected : e.getKey().getAnnotations()) {
  93                 if (expected != null) {
  94                     Annotation actual = e.getValue().getAnnotation(expected.annotationType());
  95                     assertEquals(expected, actual);
  96                 }
  97             }
  98         }
  99     }
 100 
 101     private Method findTestMethod(Method apiMethod) {
 102         String testName = apiMethod.getName() + "Test";
 103         for (Method m : getClass().getDeclaredMethods()) {
 104             if (m.getName().equals(testName) && m.getAnnotation(Test.class) != null) {
 105                 return m;
 106             }
 107         }
 108         return null;
 109     }
 110 
 111     // @formatter:off
 112     private static final String[] untestedApiMethods = {
 113         "getDeclaringClass",
 114         "isInternal",
 115         "isFinal"
 116     };
 117     // @formatter:on
 118 
 119     /**
 120      * Ensures that any new methods added to {@link ResolvedJavaMethod} either have a test written
 121      * for them or are added to {@link #untestedApiMethods}.
 122      */
 123     @Test
 124     public void testCoverage() {
 125         Set<String> known = new HashSet<>(Arrays.asList(untestedApiMethods));
 126         for (Method m : ResolvedJavaField.class.getDeclaredMethods()) {
 127             if (m.isSynthetic()) {
 128                 continue;
 129             }
 130             if (findTestMethod(m) == null) {
 131                 assertTrue("test missing for " + m, known.contains(m.getName()));
 132             } else {
 133                 assertFalse("test should be removed from untestedApiMethods" + m, known.contains(m.getName()));
 134             }
 135         }
 136     }
 137 }