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 (os.simpleArch == "x64" | os.simpleArch == "sparcv9" | os.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.TestResolvedJavaMethod
  32  * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI jdk.vm.ci.runtime.test.TestResolvedJavaMethod
  33  */
  34 
  35 package jdk.vm.ci.runtime.test;
  36 
  37 import static org.junit.Assert.assertEquals;
  38 import static org.junit.Assert.assertFalse;
  39 import static org.junit.Assert.assertNotNull;
  40 import static org.junit.Assert.assertTrue;
  41 
  42 import java.lang.annotation.Annotation;
  43 import java.lang.annotation.ElementType;
  44 import java.lang.annotation.Retention;
  45 import java.lang.annotation.RetentionPolicy;
  46 import java.lang.annotation.Target;
  47 import java.lang.invoke.MethodHandle;
  48 import java.lang.reflect.Constructor;
  49 import java.lang.reflect.Member;
  50 import java.lang.reflect.Method;
  51 import java.lang.reflect.Modifier;
  52 import java.lang.reflect.Type;
  53 import java.util.Arrays;
  54 import java.util.HashMap;
  55 import java.util.HashSet;
  56 import java.util.Map;
  57 import java.util.Set;
  58 
  59 import jdk.vm.ci.meta.ConstantPool;
  60 import jdk.vm.ci.meta.ExceptionHandler;
  61 import jdk.vm.ci.meta.ResolvedJavaMethod;
  62 import jdk.vm.ci.meta.ResolvedJavaType;
  63 
  64 import org.junit.Assert;
  65 import org.junit.Test;
  66 
  67 /**
  68  * Tests for {@link ResolvedJavaMethod}.
  69  */
  70 public class TestResolvedJavaMethod extends MethodUniverse {
  71 
  72     public TestResolvedJavaMethod() {
  73     }
  74 
  75     /**
  76      * @see ResolvedJavaMethod#getCode()
  77      */
  78     @Test
  79     public void getCodeTest() {
  80         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
  81             ResolvedJavaMethod m = e.getValue();
  82             byte[] code = m.getCode();
  83             if (code == null) {
  84                 assertTrue(m.getCodeSize() == 0);
  85             } else {
  86                 if (m.isAbstract()) {
  87                     assertTrue(code.length == 0);
  88                 } else if (!m.isNative()) {
  89                     assertTrue(code.length > 0);
  90                 }
  91             }
  92         }
  93     }
  94 
  95     /**
  96      * @see ResolvedJavaMethod#getCodeSize()
  97      */
  98     @Test
  99     public void getCodeSizeTest() {
 100         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 101             ResolvedJavaMethod m = e.getValue();
 102             int codeSize = m.getCodeSize();
 103             if (m.isAbstract()) {
 104                 assertTrue(codeSize == 0);
 105             } else if (!m.isNative()) {
 106                 assertTrue(codeSize > 0);
 107             }
 108         }
 109     }
 110 
 111     @Test
 112     public void getModifiersTest() {
 113         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 114             ResolvedJavaMethod m = e.getValue();
 115             int expected = e.getKey().getModifiers();
 116             int actual = m.getModifiers();
 117             assertEquals(String.format("%s: 0x%x != 0x%x", m, expected, actual), expected, actual);
 118         }
 119         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 120             ResolvedJavaMethod m = e.getValue();
 121             int expected = e.getKey().getModifiers();
 122             int actual = m.getModifiers();
 123             assertEquals(String.format("%s: 0x%x != 0x%x", m, expected, actual), expected, actual);
 124         }
 125     }
 126 
 127     /**
 128      * @see ResolvedJavaMethod#isClassInitializer()
 129      */
 130     @Test
 131     public void isClassInitializerTest() {
 132         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 133             // Class initializers are hidden from reflection
 134             ResolvedJavaMethod m = e.getValue();
 135             assertFalse(m.isClassInitializer());
 136         }
 137         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 138             ResolvedJavaMethod m = e.getValue();
 139             assertFalse(m.isClassInitializer());
 140         }
 141     }
 142 
 143     @Test
 144     public void isConstructorTest() {
 145         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 146             ResolvedJavaMethod m = e.getValue();
 147             assertFalse(m.isConstructor());
 148         }
 149         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 150             ResolvedJavaMethod m = e.getValue();
 151             assertTrue(m.isConstructor());
 152         }
 153     }
 154 
 155     @Test
 156     public void isSyntheticTest() {
 157         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 158             ResolvedJavaMethod m = e.getValue();
 159             assertEquals(e.getKey().isSynthetic(), m.isSynthetic());
 160         }
 161         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 162             ResolvedJavaMethod m = e.getValue();
 163             assertEquals(e.getKey().isSynthetic(), m.isSynthetic());
 164         }
 165     }
 166 
 167     @Test
 168     public void isBridgeTest() {
 169         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 170             ResolvedJavaMethod m = e.getValue();
 171             assertEquals(e.getKey().isBridge(), m.isBridge());
 172         }
 173         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 174             ResolvedJavaMethod m = e.getValue();
 175             assertEquals(false, m.isBridge());
 176         }
 177     }
 178 
 179     @Test
 180     public void isVarArgsTest() {
 181         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 182             ResolvedJavaMethod m = e.getValue();
 183             assertEquals(e.getKey().isVarArgs(), m.isVarArgs());
 184         }
 185         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 186             ResolvedJavaMethod m = e.getValue();
 187             assertEquals(e.getKey().isVarArgs(), m.isVarArgs());
 188         }
 189     }
 190 
 191     @Test
 192     public void isSynchronizedTest() {
 193         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 194             ResolvedJavaMethod m = e.getValue();
 195             assertEquals(Modifier.isSynchronized(e.getKey().getModifiers()), m.isSynchronized());
 196         }
 197         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 198             ResolvedJavaMethod m = e.getValue();
 199             assertEquals(Modifier.isSynchronized(e.getKey().getModifiers()), m.isSynchronized());
 200         }
 201     }
 202 
 203     @Test
 204     public void canBeStaticallyBoundTest() {
 205         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 206             ResolvedJavaMethod m = e.getValue();
 207             assertEquals(m.canBeStaticallyBound(), canBeStaticallyBound(e.getKey()));
 208         }
 209         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 210             ResolvedJavaMethod m = e.getValue();
 211             assertEquals(m.canBeStaticallyBound(), canBeStaticallyBound(e.getKey()));
 212         }
 213     }
 214 
 215     private static boolean canBeStaticallyBound(Member method) {
 216         int modifiers = method.getModifiers();
 217         return (Modifier.isFinal(modifiers) || Modifier.isPrivate(modifiers) || Modifier.isStatic(modifiers) || Modifier.isFinal(method.getDeclaringClass().getModifiers())) &&
 218                         !Modifier.isAbstract(modifiers);
 219     }
 220 
 221     private static String methodWithExceptionHandlers(String p1, Object o2) {
 222         try {
 223             return p1.substring(100) + o2.toString();
 224         } catch (IndexOutOfBoundsException e) {
 225             e.printStackTrace();
 226         } catch (NullPointerException e) {
 227             e.printStackTrace();
 228         } catch (RuntimeException e) {
 229             e.printStackTrace();
 230         }
 231         return null;
 232     }
 233 
 234     @Test
 235     public void getExceptionHandlersTest() throws NoSuchMethodException {
 236         ResolvedJavaMethod method = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("methodWithExceptionHandlers", String.class, Object.class));
 237         ExceptionHandler[] handlers = method.getExceptionHandlers();
 238         assertNotNull(handlers);
 239         assertEquals(handlers.length, 3);
 240         handlers[0].getCatchType().equals(metaAccess.lookupJavaType(IndexOutOfBoundsException.class));
 241         handlers[1].getCatchType().equals(metaAccess.lookupJavaType(NullPointerException.class));
 242         handlers[2].getCatchType().equals(metaAccess.lookupJavaType(RuntimeException.class));
 243     }
 244 
 245     private static String nullPointerExceptionOnFirstLine(Object o, String ignored) {
 246         return o.toString() + ignored;
 247     }
 248 
 249     @Test
 250     public void asStackTraceElementTest() throws NoSuchMethodException {
 251         try {
 252             nullPointerExceptionOnFirstLine(null, "ignored");
 253             Assert.fail("should not reach here");
 254         } catch (NullPointerException e) {
 255             StackTraceElement expected = e.getStackTrace()[0];
 256             ResolvedJavaMethod method = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("nullPointerExceptionOnFirstLine", Object.class, String.class));
 257             StackTraceElement actual = method.asStackTraceElement(0);
 258             assertEquals(expected, actual);
 259         }
 260     }
 261 
 262     @Test
 263     public void getConstantPoolTest() {
 264         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 265             ResolvedJavaMethod m = e.getValue();
 266             ConstantPool cp = m.getConstantPool();
 267             assertTrue(cp.length() > 0);
 268         }
 269     }
 270 
 271     @Retention(RetentionPolicy.RUNTIME)
 272     @Target(ElementType.METHOD)
 273     @interface TestAnnotation {
 274         long value();
 275     }
 276 
 277     @Test
 278     @TestAnnotation(value = 1000L)
 279     public void getAnnotationTest() throws NoSuchMethodException {
 280         ResolvedJavaMethod method = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("getAnnotationTest"));
 281         TestAnnotation annotation = method.getAnnotation(TestAnnotation.class);
 282         assertNotNull(annotation);
 283         assertEquals(1000L, annotation.value());
 284     }
 285 
 286     @Test
 287     @TestAnnotation(value = 1000L)
 288     public void getAnnotationsTest() throws NoSuchMethodException {
 289         ResolvedJavaMethod method = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("getAnnotationsTest"));
 290         Annotation[] annotations = method.getAnnotations();
 291         assertNotNull(annotations);
 292         assertEquals(2, annotations.length);
 293         TestAnnotation annotation = null;
 294         for (Annotation a : annotations) {
 295             if (a instanceof TestAnnotation) {
 296                 annotation = (TestAnnotation) a;
 297                 break;
 298             }
 299         }
 300         assertNotNull(annotation);
 301         assertEquals(1000L, annotation.value());
 302     }
 303 
 304     @Retention(RetentionPolicy.RUNTIME)
 305     @Target(ElementType.PARAMETER)
 306     @interface NonNull {
 307     }
 308 
 309     @Retention(RetentionPolicy.RUNTIME)
 310     @Target(ElementType.PARAMETER)
 311     @interface Special {
 312     }
 313 
 314     private static native void methodWithAnnotatedParameters(@NonNull HashMap<String, String> p1, @Special @NonNull Class<? extends Annotation> p2);
 315 
 316     @Test
 317     public void getParameterAnnotationsTest() throws NoSuchMethodException {
 318         ResolvedJavaMethod method = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("methodWithAnnotatedParameters", HashMap.class, Class.class));
 319         Annotation[][] annotations = method.getParameterAnnotations();
 320         assertEquals(2, annotations.length);
 321         assertEquals(1, annotations[0].length);
 322         assertEquals(NonNull.class, annotations[0][0].annotationType());
 323         assertEquals(2, annotations[1].length);
 324         assertEquals(Special.class, annotations[1][0].annotationType());
 325         assertEquals(NonNull.class, annotations[1][1].annotationType());
 326     }
 327 
 328     @Test
 329     public void getGenericParameterTypesTest() throws NoSuchMethodException {
 330         ResolvedJavaMethod method = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("methodWithAnnotatedParameters", HashMap.class, Class.class));
 331         Type[] genericParameterTypes = method.getGenericParameterTypes();
 332         assertEquals(2, genericParameterTypes.length);
 333         assertEquals("java.util.HashMap<java.lang.String, java.lang.String>", genericParameterTypes[0].toString());
 334         assertEquals("java.lang.Class<? extends java.lang.annotation.Annotation>", genericParameterTypes[1].toString());
 335     }
 336 
 337     @Test
 338     public void getMaxLocalsTest() throws NoSuchMethodException {
 339         ResolvedJavaMethod method1 = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("methodWithAnnotatedParameters", HashMap.class, Class.class));
 340         ResolvedJavaMethod method2 = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("nullPointerExceptionOnFirstLine", Object.class, String.class));
 341         assertEquals(0, method1.getMaxLocals());
 342         assertEquals(2, method2.getMaxLocals());
 343 
 344     }
 345 
 346     @Test
 347     public void getMaxStackSizeTest() throws NoSuchMethodException {
 348         ResolvedJavaMethod method1 = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("methodWithAnnotatedParameters", HashMap.class, Class.class));
 349         ResolvedJavaMethod method2 = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("nullPointerExceptionOnFirstLine", Object.class, String.class));
 350         assertEquals(0, method1.getMaxStackSize());
 351         // some versions of javac produce bytecode with a stacksize of 2 for this method
 352         // JSR 292 also sometimes need one more stack slot
 353         int method2StackSize = method2.getMaxStackSize();
 354         assertTrue(2 <= method2StackSize && method2StackSize <= 4);
 355     }
 356 
 357     @Test
 358     public void isDefaultTest() {
 359         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 360             ResolvedJavaMethod m = e.getValue();
 361             assertEquals(e.getKey().isDefault(), m.isDefault());
 362         }
 363         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 364             ResolvedJavaMethod m = e.getValue();
 365             assertFalse(m.isDefault());
 366         }
 367     }
 368 
 369     @Test
 370     public void hasReceiverTest() {
 371         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 372             ResolvedJavaMethod m = e.getValue();
 373             assertTrue(m.hasReceiver() != Modifier.isStatic(e.getKey().getModifiers()));
 374         }
 375         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 376             ResolvedJavaMethod m = e.getValue();
 377             assertTrue(m.hasReceiver());
 378         }
 379     }
 380 
 381     @Test
 382     public void hasBytecodesTest() {
 383         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 384             ResolvedJavaMethod m = e.getValue();
 385             assertTrue(m.hasBytecodes() == (m.isConcrete() && !m.isNative()));
 386         }
 387         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 388             ResolvedJavaMethod m = e.getValue();
 389             assertTrue(m.hasBytecodes());
 390         }
 391     }
 392 
 393     @Test
 394     public void isJavaLangObjectInitTest() throws NoSuchMethodException {
 395         ResolvedJavaMethod method = metaAccess.lookupJavaMethod(Object.class.getConstructor());
 396         assertTrue(method.isJavaLangObjectInit());
 397         for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
 398             ResolvedJavaMethod m = e.getValue();
 399             assertFalse(m.isJavaLangObjectInit());
 400         }
 401         for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
 402             ResolvedJavaMethod m = e.getValue();
 403             Constructor<?> key = e.getKey();
 404             if (key.getDeclaringClass() == Object.class && key.getParameters().length == 0) {
 405                 assertTrue(m.isJavaLangObjectInit());
 406             } else {
 407                 assertFalse(m.isJavaLangObjectInit());
 408             }
 409         }
 410     }
 411 
 412     @Test
 413     public void isSignaturePolymorphicTest() {
 414         ResolvedJavaType methodHandleType = metaAccess.lookupJavaType(MethodHandle.class);
 415         assertTrue(ResolvedJavaMethod.isSignaturePolymorphic(methodHandleType, "invokeExact", metaAccess));
 416         assertTrue(ResolvedJavaMethod.isSignaturePolymorphic(methodHandleType, "invoke", metaAccess));
 417         assertTrue(ResolvedJavaMethod.isSignaturePolymorphic(methodHandleType, "invokeBasic", metaAccess));
 418         assertTrue(ResolvedJavaMethod.isSignaturePolymorphic(methodHandleType, "linkToVirtual", metaAccess));
 419         assertTrue(ResolvedJavaMethod.isSignaturePolymorphic(methodHandleType, "linkToStatic", metaAccess));
 420         assertTrue(ResolvedJavaMethod.isSignaturePolymorphic(methodHandleType, "linkToSpecial", metaAccess));
 421         assertTrue(ResolvedJavaMethod.isSignaturePolymorphic(methodHandleType, "linkToInterface", metaAccess));
 422         assertFalse(ResolvedJavaMethod.isSignaturePolymorphic(methodHandleType, "type", metaAccess));
 423         assertFalse(ResolvedJavaMethod.isSignaturePolymorphic(metaAccess.lookupJavaType(Object.class), "toString", metaAccess));
 424     }
 425 
 426     private Method findTestMethod(Method apiMethod) {
 427         String testName = apiMethod.getName() + "Test";
 428         for (Method m : getClass().getDeclaredMethods()) {
 429             if (m.getName().equals(testName) && m.getAnnotation(Test.class) != null) {
 430                 return m;
 431             }
 432         }
 433         return null;
 434     }
 435 
 436     // @formatter:off
 437     private static final String[] untestedApiMethods = {
 438         "invoke",
 439         "newInstance",
 440         "getDeclaringClass",
 441         "getEncoding",
 442         "getProfilingInfo",
 443         "reprofile",
 444         "getCompilerStorage",
 445         "canBeInlined",
 446         "shouldBeInlined",
 447         "getLineNumberTable",
 448         "getLocalVariableTable",
 449         "isInVirtualMethodTable",
 450         "toParameterTypes",
 451         "getParameterAnnotation",
 452         "getSpeculationLog",
 453         "isFinal",
 454         "$jacocoInit"
 455     };
 456     // @formatter:on
 457 
 458     /**
 459      * Ensures that any new methods added to {@link ResolvedJavaMethod} either have a test written
 460      * for them or are added to {@link #untestedApiMethods}.
 461      */
 462     @Test
 463     public void testCoverage() {
 464         Set<String> known = new HashSet<>(Arrays.asList(untestedApiMethods));
 465         for (Method m : ResolvedJavaMethod.class.getDeclaredMethods()) {
 466             if (Modifier.isStatic(m.getModifiers())) {
 467                 continue;
 468             }
 469             if (findTestMethod(m) == null) {
 470                 assertTrue("test missing for " + m, known.contains(m.getName()));
 471             } else {
 472                 assertFalse("test should be removed from untestedApiMethods" + m, known.contains(m.getName()));
 473             }
 474         }
 475     }
 476 }