1 files changed, 51 insertions, 4 deletions

diff --git a/test/912-classes/src/Main.java b/test/912-classes/src/Main.java
index 6ad23a4869..cec69194fe 100644
--- a/test/912-classes/src/Main.java
+++ b/test/912-classes/src/Main.java
@@ -219,6 +219,14 @@ public class Main {
     }
     final ClassLoader boot = cl;
 
+    // The JIT may deeply inline and load some classes. Preload these for test determinism.
+    final String PRELOAD_FOR_JIT[] = {
+        "java.nio.charset.CoderMalfunctionError"
+    };
+    for (String s : PRELOAD_FOR_JIT) {
+      Class.forName(s);
+    }
+
     Runnable r = new Runnable() {
       @Override
       public void run() {
@@ -238,7 +246,7 @@ public class Main {
 
     ensureJitCompiled(Main.class, "testClassEvents");
 
-    enableClassLoadEvents(true);
+    enableClassLoadPreparePrintEvents(true);
 
     ClassLoader cl1 = create(boot, DEX1, DEX2);
     System.out.println("B, false");
@@ -270,7 +278,37 @@ public class Main {
     t.start();
     t.join();
 
-    enableClassLoadEvents(false);
+    enableClassLoadPreparePrintEvents(false);
+
+    // Note: the JIT part of this test is about the JIT pulling in a class not yet touched by
+    //       anything else in the system. This could be the verifier or the interpreter. We
+    //       block the interpreter by calling ensureJitCompiled. The verifier, however, must
+    //       run in configurations where dex2oat didn't verify the class itself. So explicitly
+    //       check whether the class has been already loaded, and skip then.
+    // TODO: Add multiple configurations to the run script once that becomes easier to do.
+    if (hasJit() && !isLoadedClass("Main$ClassD")) {
+      testClassEventsJit();
+    }
+  }
+
+  private static void testClassEventsJit() throws Exception {
+    enableClassLoadSeenEvents(true);
+
+    testClassEventsJitImpl();
+
+    enableClassLoadSeenEvents(false);
+
+    if (!hadLoadEvent()) {
+      throw new RuntimeException("Did not get expected load event.");
+    }
+  }
+
+  private static void testClassEventsJitImpl() throws Exception {
+    ensureJitCompiled(Main.class, "testClassEventsJitImpl");
+
+    if (ClassD.x != 1) {
+      throw new RuntimeException("Unexpected value");
+    }
   }
 
   private static void printClassLoaderClasses(ClassLoader cl) {
@@ -335,9 +373,14 @@ public class Main {
 
   private static native int[] getClassVersion(Class<?> c);
 
-  private static native void enableClassLoadEvents(boolean b);
+  private static native void enableClassLoadPreparePrintEvents(boolean b);
+
+  private static native void ensureJitCompiled(Class<?> c, String name);
 
-  private static native void ensureJitCompiled(Class c, String name);
+  private static native boolean hasJit();
+  private static native boolean isLoadedClass(String name);
+  private static native void enableClassLoadSeenEvents(boolean b);
+  private static native boolean hadLoadEvent();
 
   private static class TestForNonInit {
     public static double dummy = Math.random();  // So it can't be compile-time initialized.
@@ -361,6 +404,10 @@ public class Main {
   public abstract static class ClassC implements InfA, InfC {
   }
 
+  public static class ClassD {
+    static int x = 1;
+  }
+
   private static final String DEX1 = System.getenv("DEX_LOCATION") + "/912-classes.jar";
   private static final String DEX2 = System.getenv("DEX_LOCATION") + "/912-classes-ex.jar";