< prev index next >

test/hotspot/jtreg/compiler/jvmci/compilerToVM/FindUniqueConcreteMethodTest.java

Print this page

        

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.

@@ -34,11 +34,11 @@
  *          jdk.internal.vm.ci/jdk.vm.ci.code
  *          jdk.internal.vm.ci/jdk.vm.ci.meta
  *          jdk.internal.vm.ci/jdk.vm.ci.runtime
  * @build jdk.internal.vm.ci/jdk.vm.ci.hotspot.CompilerToVMHelper
  * @run main/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
- *                   -XX:-UseJVMCICompiler
+ *                   -Djvmci.Compiler=null
  *                   compiler.jvmci.compilerToVM.FindUniqueConcreteMethodTest
  */
 
 package compiler.jvmci.compilerToVM;
 

@@ -77,11 +77,11 @@
         // a public method
         result.add(new TestCase(true, SingleSubclass.class, "usualMethod"));
         // overriden method
         result.add(new TestCase(true, SingleSubclass.class, "overridenMethod"));
         // private method
-        result.add(new TestCase(InternalError.class, SingleSubclass.class, "privateMethod"));
+        result.add(new TestCase(true, SingleSubclass.class, "privateMethod"));
         // protected method
         result.add(new TestCase(true, SingleSubclass.class, "protectedMethod"));
         // default(package-private) method
         result.add(new TestCase(true, SingleSubclass.class, "defaultAccessMethod"));
         // default interface method redefined in implementer

@@ -90,11 +90,11 @@
         result.add(new TestCase(true, MultipleImplementer1.class, "testMethod"));
         // default interface method not redefined in implementer
         // result.add(new TestCase(true, SingleImplementer.class,
         //                         SingleImplementerInterface.class, "defaultMethod"));
         // static method
-        result.add(new TestCase(InternalError.class, SingleSubclass.class, "staticMethod"));
+        result.add(new TestCase(false, SingleSubclass.class, "staticMethod"));
         // interface method
         result.add(new TestCase(false, MultipleSuperImplementers.class,
                                 DuplicateSimpleSingleImplementerInterface.class, "interfaceMethod"));
         result.add(new TestCase(false, MultipleSuperImplementers.class,
                                 SimpleSingleImplementerInterface.class, "interfaceMethod"));

@@ -107,59 +107,36 @@
         HotSpotResolvedJavaMethod testMethod = CTVMUtilities.getResolvedMethod(method);
 
         HotSpotResolvedObjectType resolvedType = CompilerToVMHelper
                 .lookupTypeHelper(Utils.toJVMTypeSignature(tcase.receiver), getClass(),
                 /* resolve = */ true);
-        if (tcase.exception != null) {
-            try {
-                HotSpotResolvedJavaMethod concreteMethod = CompilerToVMHelper
-                        .findUniqueConcreteMethod(resolvedType, testMethod);
-
-                Asserts.fail("Exception " + tcase.exception.getName() + " not thrown for " + tcase.methodName);
-            } catch (Throwable t) {
-                Asserts.assertEQ(t.getClass(), tcase.exception, "Wrong exception thrown for " + tcase.methodName);
-            }
-        } else {
-            HotSpotResolvedJavaMethod concreteMethod = CompilerToVMHelper
-                    .findUniqueConcreteMethod(resolvedType, testMethod);
-            Asserts.assertEQ(concreteMethod, tcase.isPositive ? testMethod : null,
-                    "Unexpected concrete method for " + tcase.methodName);
-        }
+        HotSpotResolvedJavaMethod concreteMethod = CompilerToVMHelper
+                .findUniqueConcreteMethod(resolvedType, testMethod);
+        Asserts.assertEQ(concreteMethod, tcase.isPositive ? testMethod : null,
+                "Unexpected concrete method for " + tcase.methodName);
     }
 
     private static class TestCase {
         public final Class<?> receiver;
         public final Class<?> holder;
         public final String methodName;
         public final boolean isPositive;
-        public final Class<?> exception;
 
         public TestCase(boolean isPositive, Class<?> clazz, Class<?> holder,
-                        String methodName, Class<?> exception) {
+                        String methodName) {
             this.receiver = clazz;
             this.methodName = methodName;
             this.isPositive = isPositive;
             this.holder = holder;
-            this.exception = exception;
-        }
-
-        public TestCase(boolean isPositive, Class<?> clazz, Class<?> holder,
-                        String methodName) {
-            this(isPositive, clazz, holder, methodName, null);
         }
 
         public TestCase(boolean isPositive, Class<?> clazz, String methodName) {
-            this(isPositive, clazz, clazz, methodName, null);
-        }
-
-        public TestCase(Class<?> exception, Class<?> clazz, String methodName) {
-            this(false, clazz, clazz, methodName, exception);
+            this(isPositive, clazz, clazz, methodName);
         }
 
         @Override
         public String toString() {
-            return String.format("CASE: receiver=%s, holder=%s, method=%s, isPositive=%s, exception=%s",
-                                 receiver.getName(), holder.getName(), methodName, isPositive,
-                                 exception == null ? "<none>" : exception.getName());
+            return String.format("CASE: receiver=%s, holder=%s, method=%s, isPositive=%s",
+                                 receiver.getName(), holder.getName(), methodName, isPositive);
         }
     }
 }
< prev index next >