# HG changeset patch
# Parent db1a815d2f6c59687d74efdbf0186f44459068ce
8078353: test for CompilerToVM executeInstalledCode method

diff -r db1a815d2f6c test/compiler/jvmci/compilerToVM/CompileCodeTestCase.java
--- a/test/compiler/jvmci/compilerToVM/CompileCodeTestCase.java	Thu Sep 24 15:35:49 2015 -1000
+++ b/test/compiler/jvmci/compilerToVM/CompileCodeTestCase.java	Fri Sep 25 20:14:08 2015 +0300
@@ -109,7 +109,7 @@
     private static interface Interface {
         Interface interfaceMethod();
         default Long defaultOverridedMethod(Interface[] array) {
-            return (long) array.length;
+            return array == null ? 0L : array.length;
         }
         default int defaultMethod(Object o) {
             return o != null ? o.hashCode() : 0;
@@ -136,6 +136,23 @@
     }
 
     public static class DummyEx extends Dummy {
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            return true;
+
+        }
+
+        @Override
+        public int hashCode() {
+            return 0;
+        }
+
         public DummyEx() {
         }
 
@@ -155,5 +172,6 @@
         public Interface interfaceMethod() {
             return null;
         }
+
     }
 }
diff -r db1a815d2f6c test/compiler/jvmci/compilerToVM/ExecuteInstalledCodeTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/compiler/jvmci/compilerToVM/ExecuteInstalledCodeTest.java	Fri Sep 25 20:14:08 2015 +0300
@@ -0,0 +1,168 @@
+package compiler.jvmci.compilerToVM;
+
+import jdk.internal.jvmci.code.InstalledCode;
+import jdk.internal.jvmci.code.InvalidInstalledCodeException;
+import jdk.internal.jvmci.hotspot.CompilerToVMHelper;
+import jdk.test.lib.Asserts;
+import jdk.test.lib.Pair;
+import sun.hotspot.code.NMethod;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/*
+ * @test
+ * @bug 8136421
+ * @library /testlibrary /../../test/lib /
+ * @compile ../common/CompilerToVMHelper.java
+ * @build sun.hotspot.WhiteBox
+ *        compiler.jvmci.compilerToVM.ExecuteInstalledCodeTest
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ *                              sun.hotspot.WhiteBox$WhiteBoxPermission
+ *                              jdk.internal.jvmci.hotspot.CompilerToVMHelper
+ * @run main/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
+ *      -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ *      compiler.jvmci.compilerToVM.ExecuteInstalledCodeTest
+ */
+
+public class ExecuteInstalledCodeTest {
+    private static final CompileCodeTestCase.DummyEx DUMMY_EX
+            = new CompileCodeTestCase.DummyEx();
+
+    public static void main(String[] args) {
+        ExecuteInstalledCodeTest test
+                = new ExecuteInstalledCodeTest();
+        List<CompileCodeTestCase> testCases = new ArrayList<>();
+        testCases.addAll(CompileCodeTestCase.generate(/* bci = */ -1));
+        testCases.stream()
+                // 8137180 .filter(e -> !(e.executable instanceof Constructor))
+                .forEach(test::checkSanity);
+        test.checkNull();
+    }
+
+    private void checkNull() {
+
+    }
+
+    private void checkSanity(CompileCodeTestCase testCase) {
+        System.out.println(testCase);
+        // to have a clean state
+        testCase.deoptimize();
+        Pair<Object, ? extends Throwable> reflectionResult;
+        Object[] args = getArguments(testCase.executable);
+        reflectionResult = invoke(testCase.executable, args);
+        NMethod nMethod = testCase.compile();
+        if (nMethod == null) {
+            throw new Error(testCase + " : nmethod is null");
+        }
+        InstalledCode installedCode = new InstalledCode(
+                testCase.executable.getName());
+        installedCode.setAddress(nMethod.address);
+        Object result = null;
+        Throwable expectedException = reflectionResult.second;
+        boolean gotException = true;
+        try {
+            args = addReceiver(testCase, args);
+            result = CompilerToVMHelper.executeInstalledCode(
+                    args, installedCode);
+            gotException = false;
+        } catch (InvalidInstalledCodeException e) {
+            throw new AssertionError(
+                    testCase + " : unexpected InvalidInstalledCodeException", e);
+        } catch (Throwable t) {
+            if (expectedException == null) {
+                throw new AssertionError(testCase
+                        + " : got unexpected execption : " + t.getMessage(), t);
+            }
+
+            if (expectedException.getClass() != t.getClass()) {
+                System.err.println("exception from CompilerToVM:");
+                t.printStackTrace();
+                System.err.println("exception from reflection:");
+                expectedException.printStackTrace();
+                throw new AssertionError(String.format(
+                        "%s : got unexpected different exceptions : %s != %s",
+                        testCase, expectedException.getClass(), t.getClass()));
+            }
+        }
+        if (!gotException) {
+            Asserts.assertNull(expectedException, testCase
+                    + " : expected exception hasn't been thrown");
+        }
+        Asserts.assertEQ(reflectionResult.first, result, testCase
+                + " : different return value");
+
+    }
+
+    private Object[] addReceiver(CompileCodeTestCase testCase, Object[] args) {
+        if (!Modifier.isStatic(testCase.executable.getModifiers())) {
+            // add instance as 0th arg
+            Object[] newArgs = new Object[args.length + 1];
+            newArgs[0] = DUMMY_EX;
+            System.arraycopy(args, 0, newArgs, 1, args.length);
+            args = newArgs;
+        }
+        return args;
+    }
+
+    public Pair<Object, ? extends Throwable> invoke(Executable executable,
+                                                    Object[] args) {
+        boolean old = executable.isAccessible();
+        executable.setAccessible(true);
+        try {
+            try {
+                if (executable instanceof Method) {
+                    Method m = (Method) executable;
+                    return new Pair<>(m.invoke(DUMMY_EX, args), null);
+                }
+
+                if (executable instanceof Constructor) {
+                    Constructor c = (Constructor) executable;
+                    return new Pair<>(c.newInstance(args), null);
+                }
+            } catch (InvocationTargetException e) {
+                return new Pair<>(null, e.getCause());
+            } catch (Throwable e) {
+                return new Pair<>(null, e);
+            }
+        } finally {
+            executable.setAccessible(old);
+        }
+        throw new Error(executable + " has unsupported type "
+                + executable.getClass());
+    }
+
+    private Object[] getArguments(Executable method) {
+        Class<?>[] params = method.getParameterTypes();
+        Object[] result = new Object[params.length];
+        int i = 0;
+        for (Class<?> aClass : params) {
+            result[i++] = getArgument(aClass);
+        }
+        return result;
+    }
+    private static Map<Class<?>, Object> DEFAULT_VALUES = new HashMap<>();
+    static {
+        DEFAULT_VALUES.put(boolean.class, false);
+        DEFAULT_VALUES.put(byte.class, (byte) 0);
+        DEFAULT_VALUES.put(short.class, (short) 0);
+        DEFAULT_VALUES.put(char.class, (char) 0);
+        DEFAULT_VALUES.put(int.class, (int) 0);
+        DEFAULT_VALUES.put(long.class, (long) 0);
+        DEFAULT_VALUES.put(float.class, (float) 0);
+        DEFAULT_VALUES.put(double.class, (double) 0);
+    }
+    private Object getArgument(Class<?> aClass) {
+        if (aClass.isPrimitive()) {
+            return DEFAULT_VALUES.get(aClass);
+        }
+        return null;
+    }
+}