1 /*
   2  * Copyright (c) 2012, 2016, 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.jvmci
  27  * @library ../../../../../
  28  * @modules jdk.internal.vm.ci/jdk.vm.ci.meta
  29  *          jdk.internal.vm.ci/jdk.vm.ci.runtime
  30  *          java.base/jdk.internal.misc
  31  * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI jdk.vm.ci.runtime.test.TestResolvedJavaField
  32  */
  33 
  34 package jdk.vm.ci.runtime.test;
  35 
  36 import jdk.vm.ci.meta.ResolvedJavaField;
  37 import jdk.vm.ci.meta.ResolvedJavaMethod;
  38 import org.junit.Test;
  39 
  40 import java.lang.annotation.Annotation;
  41 import java.lang.reflect.Field;
  42 import java.lang.reflect.Method;
  43 import java.util.Arrays;
  44 import java.util.HashSet;
  45 import java.util.Map;
  46 import java.util.Set;
  47 
  48 import static org.junit.Assert.assertArrayEquals;
  49 import static org.junit.Assert.assertEquals;
  50 import static org.junit.Assert.assertFalse;
  51 import static org.junit.Assert.assertTrue;
  52 
  53 /**
  54  * Tests for {@link ResolvedJavaField}.
  55  */
  56 public class TestResolvedJavaField extends FieldUniverse {
  57 
  58     public TestResolvedJavaField() {
  59     }
  60 
  61     @Test
  62     public void getModifiersTest() {
  63         for (Map.Entry<Field, ResolvedJavaField> e : fields.entrySet()) {
  64             int expected = e.getKey().getModifiers();
  65             int actual = e.getValue().getModifiers();
  66             assertEquals(expected, actual);
  67         }
  68     }
  69 
  70     @Test
  71     public void isSyntheticTest() {
  72         for (Map.Entry<Field, ResolvedJavaField> e : fields.entrySet()) {
  73             boolean expected = e.getKey().isSynthetic();
  74             boolean actual = e.getValue().isSynthetic();
  75             assertEquals(expected, actual);
  76         }
  77     }
  78 
  79     @Test
  80     public void getAnnotationsTest() {
  81         for (Map.Entry<Field, ResolvedJavaField> e : fields.entrySet()) {
  82             Annotation[] expected = e.getKey().getAnnotations();
  83             Annotation[] actual = e.getValue().getAnnotations();
  84             assertArrayEquals(expected, actual);
  85         }
  86     }
  87 
  88     @Test
  89     public void getAnnotationTest() {
  90         for (Map.Entry<Field, ResolvedJavaField> e : fields.entrySet()) {
  91             for (Annotation expected : e.getKey().getAnnotations()) {
  92                 if (expected != null) {
  93                     Annotation actual = e.getValue().getAnnotation(expected.annotationType());
  94                     assertEquals(expected, actual);
  95                 }
  96             }
  97         }
  98     }
  99 
 100     private Method findTestMethod(Method apiMethod) {
 101         String testName = apiMethod.getName() + "Test";
 102         for (Method m : getClass().getDeclaredMethods()) {
 103             if (m.getName().equals(testName) && m.getAnnotation(Test.class) != null) {
 104                 return m;
 105             }
 106         }
 107         return null;
 108     }
 109 
 110     // @formatter:off
 111     private static final String[] untestedApiMethods = {
 112         "getDeclaringClass",
 113         "isInternal",
 114         "isFinal"
 115     };
 116     // @formatter:on
 117 
 118     /**
 119      * Ensures that any new methods added to {@link ResolvedJavaMethod} either have a test written
 120      * for them or are added to {@link #untestedApiMethods}.
 121      */
 122     @Test
 123     public void testCoverage() {
 124         Set<String> known = new HashSet<>(Arrays.asList(untestedApiMethods));
 125         for (Method m : ResolvedJavaField.class.getDeclaredMethods()) {
 126             if (m.isSynthetic()) {
 127                 continue;
 128             }
 129             if (findTestMethod(m) == null) {
 130                 assertTrue("test missing for " + m, known.contains(m.getName()));
 131             } else {
 132                 assertFalse("test should be removed from untestedApiMethods" + m, known.contains(m.getName()));
 133             }
 134         }
 135     }
 136 }