2 files changed, 113 insertions, 111 deletions

diff --git a/test/616-cha-abstract/run b/test/616-cha-abstract/run.py
index d8b4f0d26c..1e797a8e43 100644
--- a/test/616-cha-abstract/run
+++ b/test/616-cha-abstract/run.py
@@ -14,5 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Run without an app image to prevent the classes to be loaded at startup.
-exec ${RUN} "${@}" --no-app-image
+
+def run(ctx, args):
+  # Run without an app image to prevent the classes to be loaded at startup.
+  ctx.default_run(args, app_image=False)
diff --git a/test/616-cha-abstract/src/Main.java b/test/616-cha-abstract/src/Main.java
index c8093e6124..1a06337a4d 100644
--- a/test/616-cha-abstract/src/Main.java
+++ b/test/616-cha-abstract/src/Main.java
@@ -15,145 +15,145 @@
  */
 
 abstract class Base {
-  abstract void foo(int i);
+    abstract void foo(int i);
 
-  void printError(String msg) {
-    System.out.println(msg);
-  }
+    void printError(String msg) {
+        System.out.println(msg);
+    }
 }
 
 class Main1 extends Base {
-  void foo(int i) {
-    if (i != 1) {
-      printError("error1");
+    void foo(int i) {
+        if (i != 1) {
+            printError("error1");
+        }
     }
-  }
 }
 
 class Main2 extends Main1 {
-  void foo(int i) {
-    if (i != 2) {
-      printError("error2");
+    void foo(int i) {
+        if (i != 2) {
+            printError("error2");
+        }
     }
-  }
 }
 
 public class Main {
-  static Base sMain1;
-  static Base sMain2;
+    static Base sMain1;
+    static Base sMain2;
 
-  static boolean sIsOptimizing = true;
-  static boolean sHasJIT = true;
-  static volatile boolean sOtherThreadStarted;
+    static boolean sIsOptimizing = true;
+    static boolean sHasJIT = true;
+    static volatile boolean sOtherThreadStarted;
 
-  private static void assertSingleImplementation(Class<?> clazz, String method_name, boolean b) {
-    if (hasSingleImplementation(clazz, method_name) != b) {
-      System.out.println(clazz + "." + method_name +
-          " doesn't have single implementation value of " + b);
-    }
-  }
-
-  // sMain1.foo() will be always be Main1.foo() before Main2 is loaded/linked.
-  // So sMain1.foo() can be devirtualized to Main1.foo() and be inlined.
-  // After Helper.createMain2() which links in Main2, live testOverride() on stack
-  // should be deoptimized.
-  static void testOverride(boolean createMain2, boolean wait, boolean setHasJIT) {
-    if (setHasJIT) {
-      if (isInterpreted()) {
-        sHasJIT = false;
-      }
-      return;
+    private static void assertSingleImplementation(Class<?> clazz, String method_name, boolean b) {
+        if (hasSingleImplementation(clazz, method_name) != b) {
+            System.out.println(clazz + "." + method_name +
+                    " doesn't have single implementation value of " + b);
+        }
     }
 
-    if (createMain2 && (sIsOptimizing || sHasJIT)) {
-      assertIsManaged();
-    }
+    // sMain1.foo() will be always be Main1.foo() before Main2 is loaded/linked.
+    // So sMain1.foo() can be devirtualized to Main1.foo() and be inlined.
+    // After Helper.createMain2() which links in Main2, live testOverride() on stack
+    // should be deoptimized.
+    static void testOverride(boolean createMain2, boolean wait, boolean setHasJIT) {
+        if (setHasJIT) {
+            if (isInterpreted()) {
+                sHasJIT = false;
+            }
+            return;
+        }
 
-    sMain1.foo(sMain1.getClass() == Main1.class ? 1 : 2);
-
-    if (createMain2) {
-      // Wait for the other thread to start.
-      while (!sOtherThreadStarted);
-      // Create an Main2 instance and assign it to sMain2.
-      // sMain1 is kept the same.
-      sMain2 = Helper.createMain2();
-      // Wake up the other thread.
-      synchronized(Main.class) {
-        Main.class.notify();
-      }
-    } else if (wait) {
-      // This is the other thread.
-      synchronized(Main.class) {
-        sOtherThreadStarted = true;
-        // Wait for Main2 to be linked and deoptimization is triggered.
-        try {
-          Main.class.wait();
-        } catch (Exception e) {
+        if (createMain2 && (sIsOptimizing || sHasJIT)) {
+            assertIsManaged();
         }
-      }
-    }
 
-    // There should be a deoptimization here right after Main2 is linked by
-    // calling Helper.createMain2(), even though sMain1 didn't change.
-    // The behavior here would be different if inline-cache is used, which
-    // doesn't deoptimize since sMain1 still hits the type cache.
-    sMain1.foo(sMain1.getClass() == Main1.class ? 1 : 2);
-    if ((createMain2 || wait) && sHasJIT && !sIsOptimizing) {
-      // This method should be deoptimized right after Main2 is created.
-      assertIsInterpreted();
-    }
+        sMain1.foo(sMain1.getClass() == Main1.class ? 1 : 2);
+
+        if (createMain2) {
+            // Wait for the other thread to start.
+            while (!sOtherThreadStarted);
+            // Create an Main2 instance and assign it to sMain2.
+            // sMain1 is kept the same.
+            sMain2 = Helper.createMain2();
+            // Wake up the other thread.
+            synchronized(Main.class) {
+                Main.class.notify();
+            }
+        } else if (wait) {
+            // This is the other thread.
+            synchronized(Main.class) {
+                sOtherThreadStarted = true;
+                // Wait for Main2 to be linked and deoptimization is triggered.
+                try {
+                    Main.class.wait();
+                } catch (Exception e) {
+                }
+            }
+        }
+
+        // There should be a deoptimization here right after Main2 is linked by
+        // calling Helper.createMain2(), even though sMain1 didn't change.
+        // The behavior here would be different if inline-cache is used, which
+        // doesn't deoptimize since sMain1 still hits the type cache.
+        sMain1.foo(sMain1.getClass() == Main1.class ? 1 : 2);
+        if ((createMain2 || wait) && sHasJIT && !sIsOptimizing) {
+            // This method should be deoptimized right after Main2 is created.
+            assertIsInterpreted();
+        }
 
-    if (sMain2 != null) {
-      sMain2.foo(sMain2.getClass() == Main1.class ? 1 : 2);
+        if (sMain2 != null) {
+            sMain2.foo(sMain2.getClass() == Main1.class ? 1 : 2);
+        }
     }
-  }
 
-  // Test scenarios under which CHA-based devirtualization happens,
-  // and class loading that overrides a method can invalidate compiled code.
-  public static void main(String[] args) {
-    System.loadLibrary(args[0]);
+    // Test scenarios under which CHA-based devirtualization happens,
+    // and class loading that overrides a method can invalidate compiled code.
+    public static void main(String[] args) {
+        System.loadLibrary(args[0]);
 
-    if (isInterpreted()) {
-      sIsOptimizing = false;
-    }
+        if (isInterpreted()) {
+            sIsOptimizing = false;
+        }
+
+        // sMain1 is an instance of Main1. Main2 hasn't bee loaded yet.
+        sMain1 = new Main1();
 
-    // sMain1 is an instance of Main1. Main2 hasn't bee loaded yet.
-    sMain1 = new Main1();
+        ensureJitCompiled(Main.class, "testOverride");
+        testOverride(false, false, true);
 
-    ensureJitCompiled(Main.class, "testOverride");
-    testOverride(false, false, true);
+        if (sHasJIT && !sIsOptimizing) {
+            assertSingleImplementation(Base.class, "foo", true);
+            assertSingleImplementation(Main1.class, "foo", true);
+        } else {
+            // Main2 is verified ahead-of-time so it's linked in already.
+        }
 
-    if (sHasJIT && !sIsOptimizing) {
-      assertSingleImplementation(Base.class, "foo", true);
-      assertSingleImplementation(Main1.class, "foo", true);
-    } else {
-      // Main2 is verified ahead-of-time so it's linked in already.
+        // Create another thread that also calls sMain1.foo().
+        // Try to test suspend and deopt another thread.
+        new Thread() {
+            public void run() {
+                testOverride(false, true, false);
+            }
+        }.start();
+
+        // This will create Main2 instance in the middle of testOverride().
+        testOverride(true, false, false);
+        assertSingleImplementation(Base.class, "foo", false);
+        assertSingleImplementation(Main1.class, "foo", false);
     }
 
-    // Create another thread that also calls sMain1.foo().
-    // Try to test suspend and deopt another thread.
-    new Thread() {
-      public void run() {
-        testOverride(false, true, false);
-      }
-    }.start();
-
-    // This will create Main2 instance in the middle of testOverride().
-    testOverride(true, false, false);
-    assertSingleImplementation(Base.class, "foo", false);
-    assertSingleImplementation(Main1.class, "foo", false);
-  }
-
-  private static native void ensureJitCompiled(Class<?> itf, String method_name);
-  private static native void assertIsInterpreted();
-  private static native void assertIsManaged();
-  private static native boolean isInterpreted();
-  private static native boolean hasSingleImplementation(Class<?> clazz, String method_name);
+    private static native void ensureJitCompiled(Class<?> itf, String method_name);
+    private static native void assertIsInterpreted();
+    private static native void assertIsManaged();
+    private static native boolean isInterpreted();
+    private static native boolean hasSingleImplementation(Class<?> clazz, String method_name);
 }
 
 // Put createMain2() in another class to avoid class loading due to verifier.
 class Helper {
-  static Main1 createMain2() {
-    return new Main2();
-  }
+    static Main1 createMain2() {
+        return new Main2();
+    }
 }