Refactor builder intrinsic tests.

Move tests for building HIR for intrinsics in instruction builder to a single test. Remove duplicate rotate tests. Enable these tests on the RI (some were disabled in the known failures, some by using src-art, some were enabled). Drop the unnecessary `--experimental method-handles`-passing build script that used to be in 709-checker-varhandles. Test: testrunner.py --host --optimizing --jvm (Ignore pre-existing --jvm failures.) Change-Id: Iee799c5f5daa6b1ba711e834fb93156c5e5e8fa8
author: Vladimir Marko <vmarko@google.com> 2020-04-21 18:06:43 +0100
committer: Treehugger Robot <treehugger-gerrit@google.com> 2020-04-28 10:15:53 +0000
commit: c2a769d4821dd26291653dda51a8a98418410bb5 (patch)
tree: 5811f4928cf5a3ca512b7d8fa57a40025a2796b0
parent: bf10f659d032564575366d55d82dabc5ffcb5eaf (diff)
31 files changed, 291 insertions, 395 deletions
diff --git a/test/557-checker-instruct-simplifier-ror/src/Main.java b/test/557-checker-instruct-simplifier-ror/src/Main.java
index 1c52f07d8d..5d4bb7ab33 100644
--- a/test/557-checker-instruct-simplifier-ror/src/Main.java
+++ b/test/557-checker-instruct-simplifier-ror/src/Main.java
@@ -28,64 +28,6 @@ public class Main {
     }
   }
 
-  /// CHECK-START: int Main.rotateIntegerRight(int, int) builder (after)
-  /// CHECK:          <<ArgValue:i\d+>>     ParameterValue
-  /// CHECK:          <<ArgDistance:i\d+>>  ParameterValue
-  /// CHECK:          <<Ror:i\d+>>          Ror [<<ArgValue>>,<<ArgDistance>>]
-  /// CHECK:                                Return [<<Ror>>]
-
-  /// CHECK-START: int Main.rotateIntegerRight(int, int) builder (after)
-  /// CHECK-NOT:      LoadClass
-  /// CHECK-NOT:      ClinitCheck
-  /// CHECK-NOT:      InvokeStaticOrDirect
-  public static int rotateIntegerRight(int value, int distance) {
-    return Integer.rotateRight(value, distance);
-  }
-
-  /// CHECK-START: int Main.rotateIntegerLeft(int, int) builder (after)
-  /// CHECK:          <<ArgValue:i\d+>>     ParameterValue
-  /// CHECK:          <<ArgDistance:i\d+>>  ParameterValue
-  /// CHECK:          <<Neg:i\d+>>          Neg [<<ArgDistance>>]
-  /// CHECK:          <<Ror:i\d+>>          Ror [<<ArgValue>>,<<Neg>>]
-  /// CHECK:                                Return [<<Ror>>]
-
-  /// CHECK-START: int Main.rotateIntegerLeft(int, int) builder (after)
-  /// CHECK-NOT:      LoadClass
-  /// CHECK-NOT:      ClinitCheck
-  /// CHECK-NOT:      InvokeStaticOrDirect
-  public static int rotateIntegerLeft(int value, int distance) {
-    return Integer.rotateLeft(value, distance);
-  }
-
-  /// CHECK-START: long Main.rotateLongRight(long, int) builder (after)
-  /// CHECK:          <<ArgValue:j\d+>>     ParameterValue
-  /// CHECK:          <<ArgDistance:i\d+>>  ParameterValue
-  /// CHECK:          <<Ror:j\d+>>          Ror [<<ArgValue>>,<<ArgDistance>>]
-  /// CHECK:                                Return [<<Ror>>]
-
-  /// CHECK-START: long Main.rotateLongRight(long, int) builder (after)
-  /// CHECK-NOT:      LoadClass
-  /// CHECK-NOT:      ClinitCheck
-  /// CHECK-NOT:      InvokeStaticOrDirect
-  public static long rotateLongRight(long value, int distance) {
-    return Long.rotateRight(value, distance);
-  }
-
-  /// CHECK-START: long Main.rotateLongLeft(long, int) builder (after)
-  /// CHECK:          <<ArgValue:j\d+>>     ParameterValue
-  /// CHECK:          <<ArgDistance:i\d+>>  ParameterValue
-  /// CHECK:          <<Neg:i\d+>>          Neg [<<ArgDistance>>]
-  /// CHECK:          <<Ror:j\d+>>          Ror [<<ArgValue>>,<<Neg>>]
-  /// CHECK:                                Return [<<Ror>>]
-
-  /// CHECK-START: long Main.rotateLongLeft(long, int) builder (after)
-  /// CHECK-NOT:      LoadClass
-  /// CHECK-NOT:      ClinitCheck
-  /// CHECK-NOT:      InvokeStaticOrDirect
-  public static long rotateLongLeft(long value, int distance) {
-    return Long.rotateLeft(value, distance);
-  }
-
   //  (i >>> #distance) | (i << #(reg_bits - distance))
 
   /// CHECK-START: int Main.ror_int_constant_c_c(int) instruction_simplifier (before)
diff --git a/test/565-checker-rotate/expected.txt b/test/565-checker-rotate/expected.txt
deleted file mode 100644
index b0aad4deb5..0000000000
--- a/test/565-checker-rotate/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/565-checker-rotate/info.txt b/test/565-checker-rotate/info.txt
deleted file mode 100644
index c6a8091d6c..0000000000
--- a/test/565-checker-rotate/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Unit test for 32-bit and 64-bit rotate operations.
diff --git a/test/566-checker-signum/expected.txt b/test/566-checker-signum/expected.txt
deleted file mode 100644
index b0aad4deb5..0000000000
--- a/test/566-checker-signum/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/566-checker-signum/info.txt b/test/566-checker-signum/info.txt
deleted file mode 100644
index 328e494291..0000000000
--- a/test/566-checker-signum/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Unit test for 32-bit and 64-bit signum operations.
diff --git a/test/566-checker-signum/src/Main.java b/test/566-checker-signum/src/Main.java
deleted file mode 100644
index fa8e5cd1fe..0000000000
--- a/test/566-checker-signum/src/Main.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// This file is just for running on the RI as the test is ART specific.
-public class Main {
-  public static void main(String[] args) {
-    System.out.println("passed");
-  }
-}
diff --git a/test/567-checker-builder-intrinsics/expected.txt b/test/567-checker-builder-intrinsics/expected.txt
new file mode 100644
index 0000000000..9554e0d95c
--- /dev/null
+++ b/test/567-checker-builder-intrinsics/expected.txt
@@ -0,0 +1,8 @@
+TestRotate passed
+TestCompare passed
+TestSignum passed
+TestIsNan passed
+TestVarHandles passed
+TestMinMax passed
+TestAbs passed
+TestFpAbs passed
diff --git a/test/567-checker-builder-intrinsics/info.txt b/test/567-checker-builder-intrinsics/info.txt
new file mode 100644
index 0000000000..7ad7aa8cc4
--- /dev/null
+++ b/test/567-checker-builder-intrinsics/info.txt
@@ -0,0 +1,2 @@
+Tests for creating intermediate representation in InstructionBuilder for simple
+intrinsics. It also tests some simplifications for these instructions.
diff --git a/test/565-checker-rotate/src/Main.java b/test/567-checker-builder-intrinsics/src/Main.java
index 79b8555878..3320fb7753 100644
--- a/test/565-checker-rotate/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/Main.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,9 +14,15 @@
  * limitations under the License.
  */
 
-// This file is just for running on the RI as the test is ART specific.
 public class Main {
   public static void main(String args[]) {
-    System.out.println("passed");
+    TestRotate.main();
+    TestCompare.main();
+    TestSignum.main();
+    TestIsNan.main();
+    TestVarHandles.main();
+    TestMinMax.main();
+    TestAbs.main();
+    TestFpAbs.main();
   }
-}
-\ No newline at end of file
+}
diff --git a/test/681-checker-abs/src/Main.java b/test/567-checker-builder-intrinsics/src/TestAbs.java
index 7c68e178ad..defc988f09 100644
--- a/test/681-checker-abs/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestAbs.java
@@ -17,29 +17,29 @@
 /**
  * Functional tests for detecting abs.
  */
-public class Main {
+public class TestAbs {
 
   //
   // Intrinsics.
   //
 
-  /// CHECK-START: int Main.absI(int) builder (after)
+  /// CHECK-START: int TestAbs.absI(int) builder (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.absI(int) builder (after)
+  /// CHECK-START: int TestAbs.absI(int) builder (after)
   /// CHECK-NOT:              InvokeStaticOrDirect
   public static int absI(int a) {
     return Math.abs(a);
   }
 
-  /// CHECK-START: long Main.absL(long) builder (after)
+  /// CHECK-START: long TestAbs.absL(long) builder (after)
   /// CHECK-DAG: <<Par:j\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:j\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: long Main.absL(long) builder (after)
+  /// CHECK-START: long TestAbs.absL(long) builder (after)
   /// CHECK-NOT:              InvokeStaticOrDirect
   public static long absL(long a) {
     return Math.abs(a);
@@ -49,7 +49,7 @@ public class Main {
   // Types.
   //
 
-  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestAbs.abs1(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Par>>,<<Zer>>]
@@ -57,18 +57,18 @@ public class Main {
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Neg>>,<<Par>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs1(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs1(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs1(int a) {
     return a < 0 ? -a : a;
   }
 
-  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestAbs.abs2(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Par>>,<<Zer>>]
@@ -76,18 +76,18 @@ public class Main {
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Neg>>,<<Par>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs2(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs2(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs2(int a) {
     return a <= 0 ? -a : a;
   }
 
-  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestAbs.abs3(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Par>>,<<Zer>>]
@@ -95,18 +95,18 @@ public class Main {
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs3(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs3(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs3(int a) {
     return a > 0 ? a : -a;
   }
 
-  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestAbs.abs4(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -114,18 +114,18 @@ public class Main {
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs4(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs4(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs4(int a) {
     return a >= 0 ? a : -a;
   }
 
-  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestAbs.abs5(short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:s\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -133,18 +133,18 @@ public class Main {
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs5(short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:s\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs5(short) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs5(short a) {
     return a >= 0 ? a : -a;
   }
 
-  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestAbs.abs6(byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:b\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -152,18 +152,18 @@ public class Main {
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs6(byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:b\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs6(byte) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs6(byte a) {
     return a >= 0 ? a : -a;
   }
 
-  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: long TestAbs.abs7(long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:j\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:j\d+>> LongConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -171,12 +171,12 @@ public class Main {
   /// CHECK-DAG: <<Sel:j\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: long TestAbs.abs7(long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:j\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:j\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: long TestAbs.abs7(long) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static long abs7(long a) {
     return a >= 0 ? a : -a;
@@ -186,7 +186,7 @@ public class Main {
   // Complications.
   //
 
-  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestAbs.abs0(int[]) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Arr:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Arr>>,<<Zer>>]
@@ -194,12 +194,12 @@ public class Main {
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Arr>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs0(int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Arr:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Arr>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestAbs.abs0(int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs0(int[] a) {
     return a[0] >= 0 ? a[0] : -a[0];
@@ -209,58 +209,58 @@ public class Main {
   // Nop zero extension.
   //
 
-  /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (before)
+  /// CHECK-START: int TestAbs.zabs1(byte) instruction_simplifier (before)
   /// CHECK-DAG: <<Par:b\d+>> ParameterValue
   /// CHECK-DAG: <<Msk:i\d+>> IntConstant 255
   /// CHECK-DAG: <<And:i\d+>> [<<Par>>,<<Msk>>]
   /// CHECK-DAG: <<Abs:i\d+>> Abs
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (after)
+  /// CHECK-START: int TestAbs.zabs1(byte) instruction_simplifier (after)
   /// CHECK-DAG: <<Par:b\d+>> ParameterValue
   /// CHECK-DAG: <<Cnv:a\d+>> TypeConversion [<<Par>>]
   /// CHECK-DAG:              Return [<<Cnv>>]
   //
-  /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (after)
+  /// CHECK-START: int TestAbs.zabs1(byte) instruction_simplifier (after)
   /// CHECK-NOT:              Abs
   public static int zabs1(byte a) {
     return Math.abs(a & 0xff);
   }
 
-  /// CHECK-START: int Main.zabs2(short) instruction_simplifier (before)
+  /// CHECK-START: int TestAbs.zabs2(short) instruction_simplifier (before)
   /// CHECK-DAG: <<Par:s\d+>> ParameterValue
   /// CHECK-DAG: <<Msk:i\d+>> IntConstant 65535
   /// CHECK-DAG: <<And:i\d+>> [<<Msk>>,<<Par>>]
   /// CHECK-DAG: <<Abs:i\d+>> Abs
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.zabs2(short) instruction_simplifier (after)
+  /// CHECK-START: int TestAbs.zabs2(short) instruction_simplifier (after)
   /// CHECK-DAG: <<Par:s\d+>> ParameterValue
   /// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<Par>>]
   /// CHECK-DAG:              Return [<<Cnv>>]
   //
-  /// CHECK-START: int Main.zabs2(short) instruction_simplifier (after)
+  /// CHECK-START: int TestAbs.zabs2(short) instruction_simplifier (after)
   /// CHECK-NOT:              Abs
   public static int zabs2(short a) {
     return Math.abs(a & 0xffff);
   }
 
-  /// CHECK-START: int Main.zabs3(char) instruction_simplifier (before)
+  /// CHECK-START: int TestAbs.zabs3(char) instruction_simplifier (before)
   /// CHECK-DAG: <<Par:c\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.zabs3(char) instruction_simplifier (after)
+  /// CHECK-START: int TestAbs.zabs3(char) instruction_simplifier (after)
   /// CHECK-DAG: <<Par:c\d+>> ParameterValue
   /// CHECK-DAG:              Return [<<Par>>]
   //
-  /// CHECK-START: int Main.zabs3(char) instruction_simplifier (after)
+  /// CHECK-START: int TestAbs.zabs3(char) instruction_simplifier (after)
   /// CHECK-NOT:              Abs
   public static int zabs3(char a) {
     return Math.abs(a);
   }
 
-  public static void main(String[] args) {
+  public static void main() {
     // Intrinsics.
     expectEquals(10, absI(-10));
     expectEquals(20, absI(20));
@@ -293,7 +293,7 @@ public class Main {
     expectEquals(0xffff, zabs2((short) -1));
     expectEquals(1, zabs3((char) 1));
     expectEquals(0xffff, zabs3((char) -1));
-    System.out.println("passed");
+    System.out.println("TestAbs passed");
   }
 
   private static void expectEquals(int expected, int result) {
diff --git a/test/567-checker-compare/src/Main.java b/test/567-checker-builder-intrinsics/src/TestCompare.java
index fe1691d51d..185616a74a 100644
--- a/test/567-checker-compare/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestCompare.java
@@ -14,46 +14,46 @@
  * limitations under the License.
  */
 
-public class Main {
+public class TestCompare {
 
-  /// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) builder (after)
+  /// CHECK-START: void TestCompare.$opt$noinline$testReplaceInputWithItself(int) builder (after)
   /// CHECK-DAG:     <<ArgX:i\d+>>   ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
   /// CHECK-DAG:     <<Cmp:i\d+>>    Compare [<<ArgX>>,<<Zero>>]
   /// CHECK-DAG:                     GreaterThanOrEqual [<<Cmp>>,<<Zero>>]
 
-  /// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) instruction_simplifier (after)
+  /// CHECK-START: void TestCompare.$opt$noinline$testReplaceInputWithItself(int) instruction_simplifier (after)
   /// CHECK-DAG:     <<ArgX:i\d+>>   ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
   /// CHECK-DAG:                     GreaterThanOrEqual [<<ArgX>>,<<Zero>>]
 
   public static void $opt$noinline$testReplaceInputWithItself(int x) {
-    // The instruction simplifier first replaces Integer.compare(x, 0) with Compare HIR
-    // and then merges the Compare into the GreaterThanOrEqual. This is a regression
-    // test that to check that it is allowed to replace the second input of the
-    // GreaterThanOrEqual, i.e. <<Zero>>, with the very same instruction.
+    // The instruction builder first replaces Integer.compare(x, 0) with Compare HIR
+    // and then the instruction simplifier merges the Compare into the GreaterThanOrEqual.
+    // This is a regression test to check that it is allowed to replace the second
+    // input of the GreaterThanOrEqual, i.e. <<Zero>>, with the very same instruction.
     if (Integer.compare(x, 0) < 0) {
       System.out.println("OOOPS");
     }
   }
 
-  /// CHECK-START: int Main.compareBooleans(boolean, boolean) select_generator (after)
+  /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) select_generator (after)
   /// CHECK-NOT:                     Phi
 
-  /// CHECK-START: int Main.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
   /// CHECK:         <<ArgX:z\d+>>   ParameterValue
   /// CHECK:         <<ArgY:z\d+>>   ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>> Compare [<<ArgX>>,<<ArgY>>]
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
   /// CHECK-NOT:                     Select
 
   private static int compareBooleans(boolean x, boolean y) {
     return Integer.compare((x ? 1 : 0), (y ? 1 : 0));
   }
 
-  ///  CHECK-START: int Main.compareBooleans2(boolean, boolean) builder (after)
+  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) builder (after)
   ///  CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
   ///  CHECK-DAG:     <<One:i\d+>>    IntConstant 1
   ///  CHECK-DAG:     <<PhiX:i\d+>>   Phi [<<One>>,<<Zero>>]
@@ -61,10 +61,10 @@ public class Main {
   ///  CHECK-DAG:     <<Result:i\d+>> Compare [<<PhiX>>,<<PhiY>>]
   ///  CHECK-DAG:                     Return [<<Result>>]
 
-  ///  CHECK-START: int Main.compareBooleans2(boolean, boolean) builder (after)
+  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) builder (after)
   ///  CHECK-NOT:                     InvokeStaticOrDirect
 
-  ///  CHECK-START: int Main.compareBooleans2(boolean, boolean) select_generator (after)
+  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) select_generator (after)
   ///  CHECK:         <<ArgX:z\d+>>   ParameterValue
   ///  CHECK:         <<ArgY:z\d+>>   ParameterValue
   ///  CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
@@ -74,16 +74,16 @@ public class Main {
   ///  CHECK-DAG:     <<Result:i\d+>> Compare [<<SelX>>,<<SelY>>]
   ///  CHECK-DAG:                     Return [<<Result>>]
 
-  ///  CHECK-START: int Main.compareBooleans2(boolean, boolean) select_generator (after)
+  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) select_generator (after)
   ///  CHECK-NOT:                     Phi
 
-  ///  CHECK-START: int Main.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
+  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
   ///  CHECK:         <<ArgX:z\d+>>   ParameterValue
   ///  CHECK:         <<ArgY:z\d+>>   ParameterValue
   ///  CHECK-DAG:     <<Result:i\d+>> Compare [<<ArgX>>,<<ArgY>>]
   ///  CHECK-DAG:                     Return [<<Result>>]
 
-  ///  CHECK-START: int Main.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
+  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
   ///  CHECK-NOT:                     Select
 
   private static int compareBooleans2(boolean x, boolean y) {
@@ -104,55 +104,55 @@ public class Main {
     return Integer.compare(src_x, src_y);
   }
 
-  /// CHECK-START: int Main.compareBytes(byte, byte) builder (after)
+  /// CHECK-START: int TestCompare.compareBytes(byte, byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareBytes(byte, byte) builder (after)
+  /// CHECK-START: int TestCompare.compareBytes(byte, byte) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int compareBytes(byte x, byte y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareShorts(short, short) builder (after)
+  /// CHECK-START: int TestCompare.compareShorts(short, short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareShorts(short, short) builder (after)
+  /// CHECK-START: int TestCompare.compareShorts(short, short) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int compareShorts(short x, short y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareChars(char, char) builder (after)
+  /// CHECK-START: int TestCompare.compareChars(char, char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareChars(char, char) builder (after)
+  /// CHECK-START: int TestCompare.compareChars(char, char) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int compareChars(char x, char y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareInts(int, int) builder (after)
+  /// CHECK-START: int TestCompare.compareInts(int, int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareInts(int, int) builder (after)
+  /// CHECK-START: int TestCompare.compareInts(int, int) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int compareInts(int x, int y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareLongs(long, long) builder (after)
+  /// CHECK-START: int TestCompare.compareLongs(long, long) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareLongs(long, long) builder (after)
+  /// CHECK-START: int TestCompare.compareLongs(long, long) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int compareLongs(long x, long y) {
@@ -160,33 +160,33 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.compareByteShort(byte, short) builder (after)
+  /// CHECK-START: int TestCompare.compareByteShort(byte, short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareByteShort(byte, short) builder (after)
+  /// CHECK-START: int TestCompare.compareByteShort(byte, short) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareByteShort(byte x, short y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareByteChar(byte, char) builder (after)
+  /// CHECK-START: int TestCompare.compareByteChar(byte, char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareByteChar(byte, char) builder (after)
+  /// CHECK-START: int TestCompare.compareByteChar(byte, char) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareByteChar(byte x, char y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareByteInt(byte, int) builder (after)
+  /// CHECK-START: int TestCompare.compareByteInt(byte, int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareByteInt(byte, int) builder (after)
+  /// CHECK-START: int TestCompare.compareByteInt(byte, int) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareByteInt(byte x, int y) {
@@ -194,33 +194,33 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.compareShortByte(short, byte) builder (after)
+  /// CHECK-START: int TestCompare.compareShortByte(short, byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareShortByte(short, byte) builder (after)
+  /// CHECK-START: int TestCompare.compareShortByte(short, byte) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareShortByte(short x, byte y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareShortChar(short, char) builder (after)
+  /// CHECK-START: int TestCompare.compareShortChar(short, char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareShortChar(short, char) builder (after)
+  /// CHECK-START: int TestCompare.compareShortChar(short, char) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareShortChar(short x, char y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareShortInt(short, int) builder (after)
+  /// CHECK-START: int TestCompare.compareShortInt(short, int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareShortInt(short, int) builder (after)
+  /// CHECK-START: int TestCompare.compareShortInt(short, int) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareShortInt(short x, int y) {
@@ -228,33 +228,33 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.compareCharByte(char, byte) builder (after)
+  /// CHECK-START: int TestCompare.compareCharByte(char, byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareCharByte(char, byte) builder (after)
+  /// CHECK-START: int TestCompare.compareCharByte(char, byte) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareCharByte(char x, byte y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareCharShort(char, short) builder (after)
+  /// CHECK-START: int TestCompare.compareCharShort(char, short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareCharShort(char, short) builder (after)
+  /// CHECK-START: int TestCompare.compareCharShort(char, short) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareCharShort(char x, short y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareCharInt(char, int) builder (after)
+  /// CHECK-START: int TestCompare.compareCharInt(char, int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareCharInt(char, int) builder (after)
+  /// CHECK-START: int TestCompare.compareCharInt(char, int) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareCharInt(char x, int y) {
@@ -262,33 +262,33 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.compareIntByte(int, byte) builder (after)
+  /// CHECK-START: int TestCompare.compareIntByte(int, byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareIntByte(int, byte) builder (after)
+  /// CHECK-START: int TestCompare.compareIntByte(int, byte) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareIntByte(int x, byte y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareIntShort(int, short) builder (after)
+  /// CHECK-START: int TestCompare.compareIntShort(int, short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareIntShort(int, short) builder (after)
+  /// CHECK-START: int TestCompare.compareIntShort(int, short) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareIntShort(int x, short y) {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareIntChar(int, char) builder (after)
+  /// CHECK-START: int TestCompare.compareIntChar(int, char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.compareIntChar(int, char) builder (after)
+  /// CHECK-START: int TestCompare.compareIntChar(int, char) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   public static int compareIntChar(int x, char y) {
@@ -296,7 +296,7 @@ public class Main {
   }
 
 
-  public static void testCompareBooleans() throws Exception {
+  public static void testCompareBooleans() {
     expectEquals(-1, compareBooleans(false, true));
     expectEquals(-1, compareBooleans2(false, true));
 
@@ -867,7 +867,7 @@ public class Main {
   }
 
 
-  public static void main(String args[]) throws Exception {
+  public static void main() {
     $opt$noinline$testReplaceInputWithItself(42);
 
     testCompareBooleans();
@@ -893,7 +893,7 @@ public class Main {
     testCompareIntShort();
     testCompareIntChar();
 
-    System.out.println("passed");
+    System.out.println("TestCompare passed");
   }
 
   private static void expectEquals(int expected, int result) {
diff --git a/test/631-checker-fp-abs/src/Main.java b/test/567-checker-builder-intrinsics/src/TestFpAbs.java
index 6e0e6dbad6..e6c338d3e7 100644
--- a/test/631-checker-fp-abs/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestFpAbs.java
@@ -21,7 +21,7 @@
  * we require that Math.abs() clears the sign bit (but changes nothing else)
  * for all numbers, including NaN (signaling NaN may become quiet though).
  */
-public class Main {
+public class TestFpAbs {
 
   private final static boolean isDalvik =
       System.getProperty("java.vm.name").equals("Dalvik");
@@ -31,21 +31,21 @@ public class Main {
 
   public static boolean doThrow = false;
 
-  /// CHECK-START: float Main.$opt$noinline$absSP(float) builder (after)
+  /// CHECK-START: float TestFpAbs.$opt$noinline$absSP(float) builder (after)
   /// CHECK-DAG: <<Result:f\d+>> Abs
   /// CHECK-DAG:                 Return [<<Result>>]
   private static float $opt$noinline$absSP(float f) {
     return Math.abs(f);
   }
 
-  /// CHECK-START: double Main.$opt$noinline$absDP(double) builder (after)
+  /// CHECK-START: double TestFpAbs.$opt$noinline$absDP(double) builder (after)
   /// CHECK-DAG: <<Result:d\d+>> Abs
   /// CHECK-DAG:                 Return [<<Result>>]
   private static double $opt$noinline$absDP(double d) {
     return Math.abs(d);
   }
 
-  public static void main(String args[]) {
+  public static void main() {
     // A few obvious numbers.
     for (float f = -100.0f; f < 0.0f; f += 0.5f) {
       expectEqualsSP(-f, $opt$noinline$absSP(f));
@@ -129,7 +129,7 @@ public class Main {
           Double.doubleToRawLongBits($opt$noinline$absDP(d)));
     }
 
-    System.out.println("passed");
+    System.out.println("TestFpAbs passed");
   }
 
   private static void expectEquals32(int expected, int result) {
diff --git a/test/575-checker-isnan/src/Main.java b/test/567-checker-builder-intrinsics/src/TestIsNan.java
index 4773f636eb..03b76d70c8 100644
--- a/test/575-checker-isnan/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestIsNan.java
@@ -14,29 +14,29 @@
  * limitations under the License.
  */
 
-public class Main {
+public class TestIsNan {
 
-  /// CHECK-START: boolean Main.isNaN32(float) builder (after)
+  /// CHECK-START: boolean TestIsNan.isNaN32(float) builder (after)
   /// CHECK-DAG: <<Result:z\d+>> NotEqual
   /// CHECK-DAG: Return [<<Result>>]
   //
-  /// CHECK-START: boolean Main.isNaN32(float) builder (after)
+  /// CHECK-START: boolean TestIsNan.isNaN32(float) builder (after)
   /// CHECK-NOT: InvokeStaticOrDirect
   private static boolean isNaN32(float x) {
     return Float.isNaN(x);
   }
 
-  /// CHECK-START: boolean Main.isNaN64(double) builder (after)
+  /// CHECK-START: boolean TestIsNan.isNaN64(double) builder (after)
   /// CHECK-DAG: <<Result:z\d+>> NotEqual
   /// CHECK-DAG: Return [<<Result>>]
   //
-  /// CHECK-START: boolean Main.isNaN64(double) builder (after)
+  /// CHECK-START: boolean TestIsNan.isNaN64(double) builder (after)
   /// CHECK-NOT: InvokeStaticOrDirect
   private static boolean isNaN64(double x) {
     return Double.isNaN(x);
   }
 
-  public static void main(String args[]) {
+  public static void main() {
     // A few distinct numbers.
     expectFalse(isNaN32(Float.NEGATIVE_INFINITY));
     expectFalse(isNaN32(-1.0f));
@@ -101,7 +101,7 @@ public class Main {
       expectTrue(isNaN64(dvals[i]));
     }
 
-    System.out.println("passed");
+    System.out.println("TestIsNan passed");
   }
 
   private static void expectTrue(boolean value) {
diff --git a/test/679-checker-minmax/src/Main.java b/test/567-checker-builder-intrinsics/src/TestMinMax.java
index 0e13264f5a..0e88517006 100644
--- a/test/679-checker-minmax/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestMinMax.java
@@ -17,22 +17,22 @@
 /**
  * Functional tests for detecting min/max.
  */
-public class Main {
+public class TestMinMax {
 
   //
   // Direct intrinsics.
   //
 
-  /// CHECK-START: int Main.minI(int) builder (after)
+  /// CHECK-START: int TestMinMax.minI(int) builder (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Con:i\d+>> IntConstant 20
   /// CHECK-DAG: <<Min:i\d+>> Min [<<Par>>,<<Con>>]
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.minI(int) builder (after)
+  /// CHECK-START: int TestMinMax.minI(int) builder (after)
   /// CHECK-NOT:              InvokeStaticOrDirect
   //
-  /// CHECK-START-ARM64: int Main.minI(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.minI(int) disassembly (after)
   /// CHECK-NOT:              mov {{w\d+}}, #0x14
   /// CHECK:                  cmp {{w\d+}}, #0x14
   //  Check that the constant generation was handled by VIXL.
@@ -42,16 +42,16 @@ public class Main {
     return Math.min(a, 20);
   }
 
-  /// CHECK-START: long Main.minL(long) builder (after)
+  /// CHECK-START: long TestMinMax.minL(long) builder (after)
   /// CHECK-DAG: <<Par:j\d+>> ParameterValue
   /// CHECK-DAG: <<Con:j\d+>> LongConstant 20
   /// CHECK-DAG: <<Min:j\d+>> Min [<<Par>>,<<Con>>]
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: long Main.minL(long) builder (after)
+  /// CHECK-START: long TestMinMax.minL(long) builder (after)
   /// CHECK-NOT:              InvokeStaticOrDirect
   //
-  /// CHECK-START-ARM64: long Main.minL(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.minL(long) disassembly (after)
   /// CHECK-NOT:              mov {{x\d+}}, #0x14
   /// CHECK:                  cmp {{x\d+}}, #0x14
   //  Check that the constant generation was handled by VIXL.
@@ -61,16 +61,16 @@ public class Main {
     return Math.min(a, 20L);
   }
 
-  /// CHECK-START: int Main.maxI(int) builder (after)
+  /// CHECK-START: int TestMinMax.maxI(int) builder (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Con:i\d+>> IntConstant 20
   /// CHECK-DAG: <<Max:i\d+>> Max [<<Par>>,<<Con>>]
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.maxI(int) builder (after)
+  /// CHECK-START: int TestMinMax.maxI(int) builder (after)
   /// CHECK-NOT:              InvokeStaticOrDirect
   //
-  /// CHECK-START-ARM64: int Main.maxI(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.maxI(int) disassembly (after)
   /// CHECK-NOT:              mov {{w\d+}}, #0x14
   /// CHECK:                  cmp {{w\d+}}, #0x14
   //  Check that the constant generation was handled by VIXL.
@@ -80,16 +80,16 @@ public class Main {
     return Math.max(a, 20);
   }
 
-  /// CHECK-START: long Main.maxL(long) builder (after)
+  /// CHECK-START: long TestMinMax.maxL(long) builder (after)
   /// CHECK-DAG: <<Par:j\d+>> ParameterValue
   /// CHECK-DAG: <<Con:j\d+>> LongConstant 20
   /// CHECK-DAG: <<Max:j\d+>> Max [<<Par>>,<<Con>>]
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: long Main.maxL(long) builder (after)
+  /// CHECK-START: long TestMinMax.maxL(long) builder (after)
   /// CHECK-NOT:              InvokeStaticOrDirect
   //
-  /// CHECK-START-ARM64: long Main.maxL(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.maxL(long) disassembly (after)
   /// CHECK-NOT:              mov {{x\d+}}, #0x14
   /// CHECK:                  cmp {{x\d+}}, #0x14
   //  Check that the constant generation was handled by VIXL.
@@ -103,7 +103,7 @@ public class Main {
   // Special Cases
   //
 
-  /// CHECK-START-ARM64: int Main.minIntConstantZero(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.minIntConstantZero(int) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{w\d+}}, #0x0
   /// CHECK:            cmp {{w\d+}}, #0x0 (0)
@@ -113,7 +113,7 @@ public class Main {
     return Math.min(a, 0);
   }
 
-  /// CHECK-START-ARM64: int Main.minIntConstantOne(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.minIntConstantOne(int) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{w\d+}}, #0x1
   /// CHECK:            cmp {{w\d+}}, #0x1 (1)
@@ -123,7 +123,7 @@ public class Main {
     return Math.min(a, 1);
   }
 
-  /// CHECK-START-ARM64: int Main.minIntConstantMinusOne(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.minIntConstantMinusOne(int) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{w\d+}}, #0xffffffff
   /// CHECK:            cmn {{w\d+}}, #0x1 (1)
@@ -133,7 +133,7 @@ public class Main {
     return Math.min(a, -1);
   }
 
-  /// CHECK-START-ARM64: long Main.minLongConstantZero(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.minLongConstantZero(long) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{x\d+}}, #0x0
   /// CHECK:            cmp {{x\d+}}, #0x0 (0)
@@ -143,7 +143,7 @@ public class Main {
     return Math.min(a, 0L);
   }
 
-  /// CHECK-START-ARM64: long Main.minLongConstantOne(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.minLongConstantOne(long) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{x\d+}}, #0x1
   /// CHECK:            cmp {{x\d+}}, #0x1 (1)
@@ -153,7 +153,7 @@ public class Main {
     return Math.min(a, 1L);
   }
 
-  /// CHECK-START-ARM64: long Main.minLongConstantMinusOne(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.minLongConstantMinusOne(long) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{x\d+}}, #0xffffffffffffffff
   /// CHECK:            cmn {{x\d+}}, #0x1 (1)
@@ -163,7 +163,7 @@ public class Main {
     return Math.min(a, -1L);
   }
 
-  /// CHECK-START-ARM64: int Main.maxIntConstantZero(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.maxIntConstantZero(int) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{w\d+}}, #0x0
   /// CHECK:            cmp {{w\d+}}, #0x0 (0)
@@ -173,7 +173,7 @@ public class Main {
     return Math.max(a, 0);
   }
 
-  /// CHECK-START-ARM64: int Main.maxIntConstantOne(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.maxIntConstantOne(int) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{w\d+}}, #0x1
   /// CHECK:            cmp {{w\d+}}, #0x1 (1)
@@ -183,7 +183,7 @@ public class Main {
     return Math.max(a, 1);
   }
 
-  /// CHECK-START-ARM64: int Main.maxIntConstantMinusOne(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.maxIntConstantMinusOne(int) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{w\d+}}, #0xffffffff
   /// CHECK:            cmn {{w\d+}}, #0x1 (1)
@@ -193,7 +193,7 @@ public class Main {
     return Math.max(a, -1);
   }
 
-  /// CHECK-START-ARM64: int Main.maxIntLargeConstant(int) disassembly (after)
+  /// CHECK-START-ARM64: int TestMinMax.maxIntLargeConstant(int) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK:            mov {{w\d+}}, #0x2001
   /// CHECK:            cmp {{w\d+}}, {{w\d+}}
@@ -205,7 +205,7 @@ public class Main {
     return Math.max(a, 8193);
   }
 
-  /// CHECK-START-ARM64: long Main.maxLongConstantZero(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.maxLongConstantZero(long) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{x\d+}}, #0x0
   /// CHECK:            cmp {{x\d+}}, #0x0 (0)
@@ -215,7 +215,7 @@ public class Main {
     return Math.max(a, 0L);
   }
 
-  /// CHECK-START-ARM64: long Main.maxLongConstantOne(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.maxLongConstantOne(long) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{x\d+}}, #0x1
   /// CHECK:            cmp {{x\d+}}, #0x1 (1)
@@ -225,7 +225,7 @@ public class Main {
     return Math.max(a, 1L);
   }
 
-  /// CHECK-START-ARM64: long Main.maxLongConstantMinusOne(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.maxLongConstantMinusOne(long) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK-NOT:        mov {{x\d+}}, #0xffffffffffffffff
   /// CHECK:            cmn {{x\d+}}, #0x1 (1)
@@ -235,7 +235,7 @@ public class Main {
     return Math.max(a, -1L);
   }
 
-  /// CHECK-START-ARM64: long Main.maxLongLargeConstant(long) disassembly (after)
+  /// CHECK-START-ARM64: long TestMinMax.maxLongLargeConstant(long) disassembly (after)
   /// CHECK-NOT:        InvokeStaticOrDirect
   /// CHECK:            mov {{x\d+}}, #0x2001
   /// CHECK:            cmp {{x\d+}}, {{x\d+}}
@@ -251,211 +251,211 @@ public class Main {
   // Different types.
   //
 
-  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.min1(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min1(int a, int b) {
     return a < b ? a : b;
   }
 
-  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.min2(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min2(int a, int b) {
     return a <= b ? a : b;
   }
 
-  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.min3(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min3(int a, int b) {
     return a > b ? b : a;
   }
 
-  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.min4(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min4(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min4(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min4(int a, int b) {
     return a >= b ? b : a;
   }
 
-  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.min5(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:s\d+>>,<<Op2:s\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min5(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min5(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min5(short a, short b) {
     return a >= b ? b : a;
   }
 
-  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.min6(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:b\d+>>,<<Op2:b\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min6(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min6(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min6(byte a, byte b) {
     return a >= b ? b : a;
   }
 
-  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: long TestMinMax.min7(long, long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:j\d+>>,<<Op2:j\d+>>]
   /// CHECK-DAG: <<Sel:j\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: long TestMinMax.min7(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:j\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: long TestMinMax.min7(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static long min7(long a, long b) {
     return a >= b ? b : a;
   }
 
-  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.max1(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max1(int a, int b) {
     return a < b ? b : a;
   }
 
-  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.max2(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max2(int a, int b) {
     return a <= b ? b : a;
   }
 
-  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.max3(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max3(int a, int b) {
     return a > b ? a : b;
   }
 
-  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.max4(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max4(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max4(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max4(int a, int b) {
     return a >= b ? a : b;
   }
 
-  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.max5(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:s\d+>>,<<Op2:s\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max5(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max5(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max5(short a, short b) {
     return a >= b ? a : b;
   }
 
-  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.max6(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:b\d+>>,<<Op2:b\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max6(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max6(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max6(byte a, byte b) {
     return a >= b ? a : b;
   }
 
-  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: long TestMinMax.max7(long, long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:j\d+>>,<<Op2:j\d+>>]
   /// CHECK-DAG: <<Sel:j\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: long TestMinMax.max7(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:j\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: long TestMinMax.max7(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static long max7(long a, long b) {
     return a >= b ? a : b;
@@ -465,18 +465,18 @@ public class Main {
   // Complications.
   //
 
-  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.min0(int[], int[]) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Ar1:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Ar2:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Ar1>>,<<Ar2>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Ar1>>,<<Ar2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min0(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.min0(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min0(int[] a, int[] b) {
     // Repeat of array references needs finding the common subexpressions
@@ -484,18 +484,18 @@ public class Main {
     return a[0] <= b[0] ? a[0] : b[0];
   }
 
-  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.max0(int[], int[]) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Ar1:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Ar2:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Ar1>>,<<Ar2>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Ar1>>,<<Ar2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max0(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.max0(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max0(int[] a, int[] b) {
     // Repeat of array references needs finding the common subexpressions
@@ -503,7 +503,7 @@ public class Main {
     return a[0] >= b[0] ? a[0] : b[0];
   }
 
-  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.minmax1(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -513,7 +513,7 @@ public class Main {
   /// CHECK-DAG: <<Sel2:i\d+>> Select [<<M100>>,<<Sel1>>,<<Cnd2>>]
   /// CHECK-DAG:               Return [<<Sel2>>]
   //
-  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmax1(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -521,7 +521,7 @@ public class Main {
   /// CHECK-DAG: <<Max:i\d+>>  Max [<<Min>>,<<M100>>]
   /// CHECK-DAG:               Return [<<Max>>]
   //
-  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmax1(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:               Select
   public static int minmax1(int x) {
     // Simple if-if gives clean select sequence.
@@ -534,7 +534,7 @@ public class Main {
     return x;
   }
 
-  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (before)
+  /// CHECK-START: int TestMinMax.minmax2(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -544,7 +544,7 @@ public class Main {
   /// CHECK-DAG: <<Sel2:i\d+>> Select [<<P100>>,<<Sel1>>,<<Cnd1>>]
   /// CHECK-DAG:               Return [<<Sel2>>]
   //
-  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmax2(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -552,7 +552,7 @@ public class Main {
   /// CHECK-DAG: <<Min:i\d+>>  Min [<<Max>>,<<P100>>]
   /// CHECK-DAG:               Return [<<Min>>]
   //
-  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmax2(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:               Select
   public static int minmax2(int x) {
     // Simple if-else requires inspecting bounds of resulting selects.
@@ -564,7 +564,7 @@ public class Main {
     return x;
   }
 
-  /// CHECK-START: int Main.minmax3(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmax3(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -572,13 +572,13 @@ public class Main {
   /// CHECK-DAG: <<Min:i\d+>>  Min [<<Max>>,<<P100>>]
   /// CHECK-DAG:               Return [<<Min>>]
   //
-  /// CHECK-START: int Main.minmax3(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmax3(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:               Select
   public static int minmax3(int x) {
     return (x > 100) ? 100 : ((x < -100) ? -100 : x);
   }
 
-  /// CHECK-START: int Main.minmax4(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmax4(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -586,13 +586,13 @@ public class Main {
   /// CHECK-DAG: <<Max:i\d+>>  Max [<<Min>>,<<M100>>]
   /// CHECK-DAG:               Return [<<Max>>]
   //
-  /// CHECK-START: int Main.minmax4(int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmax4(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:               Select
   public static int minmax4(int x) {
     return (x < -100) ? -100 : ((x > 100) ? 100 : x);
   }
 
-  /// CHECK-START: int Main.minmaxCSEScalar(int, int) select_generator (after)
+  /// CHECK-START: int TestMinMax.minmaxCSEScalar(int, int) select_generator (after)
   /// CHECK-DAG: <<Par1:i\d+>> ParameterValue
   /// CHECK-DAG: <<Par2:i\d+>> ParameterValue
   /// CHECK-DAG: <<Cnd1:z\d+>> LessThanOrEqual    [<<Par1>>,<<Par2>>]
@@ -606,7 +606,7 @@ public class Main {
   /// CHECK-DAG: <<Add5:i\d+>> Add                [<<Sel2>>,<<Add4>>]
   /// CHECK-DAG:               Return             [<<Add5>>]
   //
-  /// CHECK-START: int Main.minmaxCSEScalar(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmaxCSEScalar(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par1:i\d+>> ParameterValue
   /// CHECK-DAG: <<Par2:i\d+>> ParameterValue
   /// CHECK-DAG: <<Max:i\d+>>  Max    [<<Par1>>,<<Par2>>]
@@ -628,7 +628,7 @@ public class Main {
     return t1 + t2 + t3 + t4 + t5 + t6;
   }
 
-  /// CHECK-START: int Main.minmaxCSEArray(int[], int[]) select_generator (after)
+  /// CHECK-START: int TestMinMax.minmaxCSEArray(int[], int[]) select_generator (after)
   /// CHECK-DAG: <<Arr1:i\d+>> ArrayGet
   /// CHECK-DAG: <<Arr2:i\d+>> ArrayGet
   /// CHECK-DAG: <<Cnd1:z\d+>> LessThanOrEqual    [<<Arr1>>,<<Arr2>>]
@@ -642,7 +642,7 @@ public class Main {
   /// CHECK-DAG: <<Add5:i\d+>> Add                [<<Sel2>>,<<Add4>>]
   /// CHECK-DAG:               Return             [<<Add5>>]
   //
-  /// CHECK-START: int Main.minmaxCSEArray(int[], int[]) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmaxCSEArray(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Arr1:i\d+>> ArrayGet
   /// CHECK-DAG: <<Arr2:i\d+>> ArrayGet
   /// CHECK-DAG: <<Max:i\d+>>  Max    [<<Arr1>>,<<Arr2>>]
@@ -664,7 +664,7 @@ public class Main {
     return t1 + t2 + t3 + t4 + t5 + t6;
   }
 
-  /// CHECK-START: int Main.minmaxCSEScalarAndCond(int, int) instruction_simplifier$after_gvn (after)
+  /// CHECK-START: int TestMinMax.minmaxCSEScalarAndCond(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par1:i\d+>> ParameterValue
   /// CHECK-DAG: <<Par2:i\d+>> ParameterValue
   /// CHECK-DAG: <<Max:i\d+>>  Max    [<<Par1>>,<<Par2>>]
@@ -686,7 +686,7 @@ public class Main {
     return t1 + t2 + t3 + t4;
   }
 
-  public static void main(String[] args) {
+  public static void main() {
     // Intrinsics.
     expectEquals(10, minI(10));
     expectEquals(20, minI(25));
@@ -760,7 +760,7 @@ public class Main {
     expectEquals(90, minmaxCSEArray(a, b));
     expectEquals(20, minmaxCSEScalarAndCond(10, 10));
     expectEquals(60, minmaxCSEScalarAndCond(10, 20));
-    System.out.println("passed");
+    System.out.println("TestMinMax passed");
   }
 
   private static void expectEquals(int expected, int result) {
diff --git a/test/565-checker-rotate/src-art/Main.java b/test/567-checker-builder-intrinsics/src/TestRotate.java
index 6efb210c43..0593e6030f 100644
--- a/test/565-checker-rotate/src-art/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestRotate.java
@@ -14,137 +14,137 @@
  * limitations under the License.
  */
 
-public class Main {
+public class TestRotate {
 
-  /// CHECK-START: int Main.rotateLeftByte(byte, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftByte(byte, int) builder (after)
   /// CHECK:         <<ArgVal:b\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<NegDist:i\d+>> Neg [<<ArgDist>>]
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateLeftByte(byte, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftByte(byte, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateLeftByte(byte value, int distance) {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateLeftShort(short, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftShort(short, int) builder (after)
   /// CHECK:         <<ArgVal:s\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<NegDist:i\d+>> Neg [<<ArgDist>>]
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateLeftShort(short, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftShort(short, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateLeftShort(short value, int distance) {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateLeftChar(char, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftChar(char, int) builder (after)
   /// CHECK:         <<ArgVal:c\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<NegDist:i\d+>> Neg [<<ArgDist>>]
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateLeftChar(char, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftChar(char, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateLeftChar(char value, int distance) {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateLeftInt(int, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftInt(int, int) builder (after)
   /// CHECK:         <<ArgVal:i\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<NegDist:i\d+>> Neg [<<ArgDist>>]
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateLeftInt(int, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftInt(int, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateLeftInt(int value, int distance) {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: long Main.rotateLeftLong(long, int) builder (after)
+  /// CHECK-START: long TestRotate.rotateLeftLong(long, int) builder (after)
   /// CHECK:         <<ArgVal:j\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<NegDist:i\d+>> Neg [<<ArgDist>>]
   /// CHECK-DAG:     <<Result:j\d+>>  Ror [<<ArgVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: long Main.rotateLeftLong(long, int) builder (after)
+  /// CHECK-START: long TestRotate.rotateLeftLong(long, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static long rotateLeftLong(long value, int distance) {
     return Long.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightByte(byte, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightByte(byte, int) builder (after)
   /// CHECK:         <<ArgVal:b\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateRightByte(byte, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightByte(byte, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateRightByte(byte value, int distance) {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightShort(short, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightShort(short, int) builder (after)
   /// CHECK:         <<ArgVal:s\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateRightShort(short, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightShort(short, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateRightShort(short value, int distance) {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightChar(char, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightChar(char, int) builder (after)
   /// CHECK:         <<ArgVal:c\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateRightChar(char, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightChar(char, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateRightChar(char value, int distance) {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightInt(int, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightInt(int, int) builder (after)
   /// CHECK:         <<ArgVal:i\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateRightInt(int, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightInt(int, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateRightInt(int value, int distance) {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: long Main.rotateRightLong(long, int) builder (after)
+  /// CHECK-START: long TestRotate.rotateRightLong(long, int) builder (after)
   /// CHECK:         <<ArgVal:j\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:j\d+>>  Ror [<<ArgVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: long Main.rotateRightLong(long, int) builder (after)
+  /// CHECK-START: long TestRotate.rotateRightLong(long, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static long rotateRightLong(long value, int distance) {
@@ -152,34 +152,34 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftIntWithByteDistance(int, byte) builder (after)
   /// CHECK:         <<ArgVal:i\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:b\d+>> ParameterValue
   /// CHECK-DAG:     <<NegDist:i\d+>> Neg [<<ArgDist>>]
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftIntWithByteDistance(int, byte) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateLeftIntWithByteDistance(int value, byte distance) {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightIntWithByteDistance(int, byte) builder (after)
   /// CHECK:         <<ArgVal:i\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:b\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightIntWithByteDistance(int, byte) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
   private static int rotateRightIntWithByteDistance(int value, byte distance) {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) builder (after)
   /// CHECK:         <<ArgVal:z\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>    IntConstant 0
@@ -189,10 +189,10 @@ public class Main {
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<Val>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
-  /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) select_generator (after)
+  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) select_generator (after)
   /// CHECK:         <<ArgVal:z\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>    IntConstant 0
@@ -202,17 +202,17 @@ public class Main {
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<SelVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) select_generator (after)
+  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) select_generator (after)
   /// CHECK-NOT:                      Phi
 
-  /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
   /// CHECK:         <<ArgVal:z\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<NegDist:i\d+>> Neg [<<ArgDist>>]
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
   /// CHECK-NOT:                      Select
 
   private static int rotateLeftBoolean(boolean value, int distance) {
@@ -227,7 +227,7 @@ public class Main {
     return Integer.rotateLeft(src, distance);
   }
 
-  public static void testRotateLeftBoolean() throws Exception {
+  public static void testRotateLeftBoolean() {
     for (int i = 0; i < 40; i++) {  // overshoot a bit
       int j = i & 31;
       expectEqualsInt(0, rotateLeftBoolean(false, i));
@@ -326,7 +326,7 @@ public class Main {
     }
   }
 
-  /// CHECK-START: int Main.rotateRightBoolean(boolean, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) builder (after)
   /// CHECK:         <<ArgVal:z\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>    IntConstant 0
@@ -335,10 +335,10 @@ public class Main {
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<Val>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateRightBoolean(boolean, int) builder (after)
+  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) builder (after)
   /// CHECK-NOT:                      InvokeStaticOrDirect
 
-  /// CHECK-START: int Main.rotateRightBoolean(boolean, int) select_generator (after)
+  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) select_generator (after)
   /// CHECK:         <<ArgVal:z\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>    IntConstant 0
@@ -347,16 +347,16 @@ public class Main {
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<SelVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateRightBoolean(boolean, int) select_generator (after)
+  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) select_generator (after)
   /// CHECK-NOT:                     Phi
 
-  /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
   /// CHECK:         <<ArgVal:z\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
   /// CHECK-NOT:                     Select
 
   private static int rotateRightBoolean(boolean value, int distance) {
@@ -371,7 +371,7 @@ public class Main {
     return Integer.rotateRight(src, distance);
   }
 
-  public static void testRotateRightBoolean() throws Exception {
+  public static void testRotateRightBoolean() {
     for (int i = 0; i < 40; i++) {  // overshoot a bit
       int j = (-i) & 31;
       expectEqualsInt(0, rotateRightBoolean(false, i));
@@ -509,7 +509,7 @@ public class Main {
   }
 
 
-  public static void main(String args[]) throws Exception {
+  public static void main() {
     testRotateLeftBoolean();
     testRotateLeftByte();
     testRotateLeftShort();
@@ -528,7 +528,7 @@ public class Main {
     testRotateLeftIntWithByteDistance();
     testRotateRightIntWithByteDistance();
 
-    System.out.println("passed");
+    System.out.println("TestRotate passed");
   }
 
 
diff --git a/test/566-checker-signum/src-art/Main.java b/test/567-checker-builder-intrinsics/src/TestSignum.java
index 8fec4de0a4..0a68ac24c8 100644
--- a/test/566-checker-signum/src-art/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestSignum.java
@@ -14,74 +14,74 @@
  * limitations under the License.
  */
 
-public class Main {
+public class TestSignum {
 
-  /// CHECK-START: int Main.signByte(byte) builder (after)
+  /// CHECK-START: int TestSignum.signByte(byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.signByte(byte) builder (after)
+  /// CHECK-START: int TestSignum.signByte(byte) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int signByte(byte x) {
     return Integer.signum(x);
   }
 
-  /// CHECK-START: int Main.signShort(short) builder (after)
+  /// CHECK-START: int TestSignum.signShort(short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.signShort(short) builder (after)
+  /// CHECK-START: int TestSignum.signShort(short) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int signShort(short x) {
     return Integer.signum(x);
   }
 
-  /// CHECK-START: int Main.signChar(char) builder (after)
+  /// CHECK-START: int TestSignum.signChar(char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.signChar(char) builder (after)
+  /// CHECK-START: int TestSignum.signChar(char) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int signChar(char x) {
     return Integer.signum(x);
   }
 
-  /// CHECK-START: int Main.signInt(int) builder (after)
+  /// CHECK-START: int TestSignum.signInt(int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.signInt(int) builder (after)
+  /// CHECK-START: int TestSignum.signInt(int) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int signInt(int x) {
     return Integer.signum(x);
   }
 
-  /// CHECK-START: int Main.signLong(long) builder (after)
+  /// CHECK-START: int TestSignum.signLong(long) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> Compare
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.signLong(long) builder (after)
+  /// CHECK-START: int TestSignum.signLong(long) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
   private static int signLong(long x) {
     return Long.signum(x);
   }
 
-  /// CHECK-START: int Main.signBoolean(boolean) builder (after)
+  /// CHECK-START: int TestSignum.signBoolean(boolean) builder (after)
   /// CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
   /// CHECK-DAG:     <<One:i\d+>>    IntConstant 1
   /// CHECK-DAG:     <<Phi:i\d+>>    Phi [<<One>>,<<Zero>>]
   /// CHECK-DAG:     <<Result:i\d+>> Compare [<<Phi>>,<<Zero>>]
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.signBoolean(boolean) builder (after)
+  /// CHECK-START: int TestSignum.signBoolean(boolean) builder (after)
   /// CHECK-NOT:                     InvokeStaticOrDirect
 
-  /// CHECK-START: int Main.signBoolean(boolean) select_generator (after)
+  /// CHECK-START: int TestSignum.signBoolean(boolean) select_generator (after)
   /// CHECK-DAG:     <<Arg:z\d+>>    ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
   /// CHECK-DAG:     <<One:i\d+>>    IntConstant 1
@@ -89,16 +89,16 @@ public class Main {
   /// CHECK-DAG:     <<Result:i\d+>> Compare [<<Sel>>,<<Zero>>]
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.signBoolean(boolean) select_generator (after)
+  /// CHECK-START: int TestSignum.signBoolean(boolean) select_generator (after)
   /// CHECK-NOT:                     Phi
 
-  /// CHECK-START: int Main.signBoolean(boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestSignum.signBoolean(boolean) instruction_simplifier$after_bce (after)
   /// CHECK-DAG:     <<Arg:z\d+>>    ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
   /// CHECK-DAG:     <<Result:i\d+>> Compare [<<Arg>>,<<Zero>>]
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int Main.signBoolean(boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestSignum.signBoolean(boolean) instruction_simplifier$after_bce (after)
   /// CHECK-NOT:                     Select
 
   private static int signBoolean(boolean x) {
@@ -113,7 +113,7 @@ public class Main {
     return Integer.signum(src_x);
   }
 
-  public static void testSignBoolean() throws Exception {
+  public static void testSignBoolean() {
     expectEquals(0, signBoolean(false));
     expectEquals(1, signBoolean(true));
   }
@@ -195,7 +195,7 @@ public class Main {
   }
 
 
-  public static void main(String args[]) throws Exception {
+  public static void main() {
     testSignBoolean();
     testSignByte();
     testSignShort();
@@ -203,7 +203,7 @@ public class Main {
     testSignInt();
     testSignLong();
 
-    System.out.println("passed");
+    System.out.println("TestSignum passed");
   }
 
   private static void expectEquals(int expected, int result) {
diff --git a/test/709-checker-varhandles/src/Main.java b/test/567-checker-builder-intrinsics/src/TestVarHandles.java
index 8bb0434592..2a82c06546 100644
--- a/test/709-checker-varhandles/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestVarHandles.java
@@ -22,52 +22,52 @@ import java.lang.invoke.VarHandle;
  * Instead, this test ensures the methods are recognized as intrinsic and behave
  * as expected.
  */
-public class Main {
+public class TestVarHandles {
 
   //
   // Fences (native).
   //
 
-  /// CHECK-START: void Main.fullFence() builder (after)
+  /// CHECK-START: void TestVarHandles.fullFence() builder (after)
   /// CHECK-NOT: InvokeStaticOrDirect
   //
-  /// CHECK-START: void Main.fullFence() builder (after)
+  /// CHECK-START: void TestVarHandles.fullFence() builder (after)
   /// CHECK-DAG: MemoryBarrier kind:AnyAny
   private static void fullFence() {
       VarHandle.fullFence();
   }
 
-  /// CHECK-START: void Main.acquireFence() builder (after)
+  /// CHECK-START: void TestVarHandles.acquireFence() builder (after)
   /// CHECK-NOT: InvokeStaticOrDirect
   //
-  /// CHECK-START: void Main.acquireFence() builder (after)
+  /// CHECK-START: void TestVarHandles.acquireFence() builder (after)
   /// CHECK-DAG: MemoryBarrier kind:LoadAny
   private static void acquireFence() {
       VarHandle.acquireFence();
   }
 
-  /// CHECK-START: void Main.releaseFence() builder (after)
+  /// CHECK-START: void TestVarHandles.releaseFence() builder (after)
   /// CHECK-NOT: InvokeStaticOrDirect
   //
-  /// CHECK-START: void Main.releaseFence() builder (after)
+  /// CHECK-START: void TestVarHandles.releaseFence() builder (after)
   /// CHECK-DAG: MemoryBarrier kind:AnyStore
   private static void releaseFence() {
       VarHandle.releaseFence();
   }
 
-  /// CHECK-START: void Main.loadLoadFence() builder (after)
+  /// CHECK-START: void TestVarHandles.loadLoadFence() builder (after)
   /// CHECK-NOT: InvokeStaticOrDirect
   //
-  /// CHECK-START: void Main.loadLoadFence() builder (after)
+  /// CHECK-START: void TestVarHandles.loadLoadFence() builder (after)
   /// CHECK-DAG: MemoryBarrier kind:LoadAny
   private static void loadLoadFence() {
       VarHandle.loadLoadFence();
   }
 
-  /// CHECK-START: void Main.storeStoreFence() builder (after)
+  /// CHECK-START: void TestVarHandles.storeStoreFence() builder (after)
   /// CHECK-NOT: InvokeStaticOrDirect
   //
-  /// CHECK-START: void Main.storeStoreFence() builder (after)
+  /// CHECK-START: void TestVarHandles.storeStoreFence() builder (after)
   /// CHECK-DAG: MemoryBarrier kind:StoreStore
   private static void storeStoreFence() {
       VarHandle.storeStoreFence();
@@ -77,13 +77,12 @@ public class Main {
   // Driver.
   //
 
-  public static void main(String[] args) {
-    System.out.println("starting");
+  public static void main() {
     acquireFence();
     releaseFence();
     loadLoadFence();
     storeStoreFence();
     fullFence();
-    System.out.println("passed");
+    System.out.println("TestVarHandles passed");
   }
 }
diff --git a/test/567-checker-compare/expected.txt b/test/567-checker-compare/expected.txt
deleted file mode 100644
index b0aad4deb5..0000000000
--- a/test/567-checker-compare/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/567-checker-compare/info.txt b/test/567-checker-compare/info.txt
deleted file mode 100644
index 5bac7b1165..0000000000
--- a/test/567-checker-compare/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Unit test for 32-bit and 64-bit compare operations.
diff --git a/test/575-checker-isnan/expected.txt b/test/575-checker-isnan/expected.txt
deleted file mode 100644
index b0aad4deb5..0000000000
--- a/test/575-checker-isnan/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/575-checker-isnan/info.txt b/test/575-checker-isnan/info.txt
deleted file mode 100644
index 5c48a6a877..0000000000
--- a/test/575-checker-isnan/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Unit test for float/double isNaN() operation.
diff --git a/test/631-checker-fp-abs/expected.txt b/test/631-checker-fp-abs/expected.txt
deleted file mode 100644
index b0aad4deb5..0000000000
--- a/test/631-checker-fp-abs/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/631-checker-fp-abs/info.txt b/test/631-checker-fp-abs/info.txt
deleted file mode 100644
index 0a1499e72c..0000000000
--- a/test/631-checker-fp-abs/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Tests on floating-point Math.abs.
diff --git a/test/679-checker-minmax/expected.txt b/test/679-checker-minmax/expected.txt
deleted file mode 100644
index b0aad4deb5..0000000000
--- a/test/679-checker-minmax/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/679-checker-minmax/info.txt b/test/679-checker-minmax/info.txt
deleted file mode 100644
index 4f7b9f52c5..0000000000
--- a/test/679-checker-minmax/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Functional tests on detecting min/max.
diff --git a/test/681-checker-abs/expected.txt b/test/681-checker-abs/expected.txt
deleted file mode 100644
index b0aad4deb5..0000000000
--- a/test/681-checker-abs/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/681-checker-abs/info.txt b/test/681-checker-abs/info.txt
deleted file mode 100644
index d36e76e504..0000000000
--- a/test/681-checker-abs/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Functional tests on detecting abs.
diff --git a/test/709-checker-varhandles/build b/test/709-checker-varhandles/build
deleted file mode 100755
index 2b0b2c1274..0000000000
--- a/test/709-checker-varhandles/build
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2016 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# make us exit on a failure
-set -e
-
-./default-build "$@" --experimental method-handles
diff --git a/test/709-checker-varhandles/expected.txt b/test/709-checker-varhandles/expected.txt
deleted file mode 100644
index 651da727af..0000000000
--- a/test/709-checker-varhandles/expected.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-starting
-passed
diff --git a/test/709-checker-varhandles/info.txt b/test/709-checker-varhandles/info.txt
deleted file mode 100644
index 222124074c..0000000000
--- a/test/709-checker-varhandles/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Test support for intrinsics in Java 9 java.lang.invoke.VarHandle.
diff --git a/test/knownfailures.json b/test/knownfailures.json
index adcdffe352..68a8101393 100644
--- a/test/knownfailures.json
+++ b/test/knownfailures.json
@@ -965,7 +965,6 @@
           "565-checker-doublenegbitwise",
           "565-checker-irreducible-loop",
           "566-polymorphic-inlining",
-          "567-checker-compare",
           "569-checker-pattern-replacement",
           "570-checker-osr",
           "571-irreducible-loop",
@@ -1009,7 +1008,6 @@
           "628-vdex",
           "629-vdex-speed",
           "630-safecast-array",
-          "631-checker-fp-abs",
           "633-checker-rtp-getclass",
           "634-vdex-duplicate",
           "636-wrong-static-access",
author	Vladimir Marko <vmarko@google.com>	2020-04-21 18:06:43 +0100
committer	Treehugger Robot <treehugger-gerrit@google.com>	2020-04-28 10:15:53 +0000
commit	c2a769d4821dd26291653dda51a8a98418410bb5 (patch)
tree	5811f4928cf5a3ca512b7d8fa57a40025a2796b0
parent	bf10f659d032564575366d55d82dabc5ffcb5eaf (diff)