improved doc and API of SubprocessTest

Author: dougxc

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/SubprocessTest.java

@@ -36,14 +36,16 @@
 import java.util.List;
 import java.util.function.Predicate;
 
+import jdk.graal.compiler.test.GraalTest;
 import jdk.graal.compiler.test.SubprocessUtil;
 import jdk.graal.compiler.test.SubprocessUtil.Subprocess;
 
 /**
  * Utility class for executing Graal compiler tests in a subprocess. This can be useful for tests
  * that need special VM arguments or that produce textual output or a special process termination
- * status that need to be analyzed. The class to be executed may be the current class or any other
- * unit test class.
+ * status that need to be analyzed. Another use case is a test that behaves very differently when
+ * run after many other tests (that fill up the heap and pollute profiles). The class to be executed
+ * may be the current class or any other unit test class.
  * <p/>
  * If the test class contains multiple {@code @Test} methods, they will all be executed in the
  * subprocess, except when using one of the methods that take a {@code testSelector} argument. All
@@ -59,24 +61,24 @@
 public abstract class SubprocessTest extends GraalCompilerTest {
 
     /**
-     * Launches the {@code runnable} in a subprocess, with any extra {@code args} passed as
-     * arguments to the subprocess VM. Checks that the subprocess terminated successfully, i.e., an
-     * exit code different from 0 raises an error.
-     *
-     * @return Inside the subprocess, returns {@code null}. Outside the subprocess, returns a
-     *         {@link Subprocess} instance describing the process after its successful termination.
+     * Calls {@link #launchSubprocess(Predicate, boolean, Class, String, Runnable, String...)} with
+     * the given args, {@code vmArgsFilter=null}, {@code check=true}, {@code testClass=getClass()}
+     * and {@code testSelector=currentUnitTestName()}.
      */
-    public SubprocessUtil.Subprocess launchSubprocess(Runnable runnable, String... args) throws InterruptedException, IOException {
-        return launchSubprocess(null, null, true, getClass(), currentUnitTestName(), runnable, args);
-    }
-
-    public SubprocessUtil.Subprocess launchSubprocess(Predicate<String> vmArgsFilter, Runnable runnable, String... args) throws InterruptedException, IOException {
-        return launchSubprocess(null, vmArgsFilter, true, getClass(), currentUnitTestName(), runnable, args);
+    public SubprocessUtil.Subprocess launchSubprocess(Runnable runnable, String... extraVmArgs) throws InterruptedException, IOException {
+        return launchSubprocess(null, true, getClass(), currentUnitTestName(), runnable, extraVmArgs);
     }
 
-    public static SubprocessUtil.Subprocess launchSubprocess(Class<? extends GraalCompilerTest> testClass, String testSelector, Runnable runnable, String... args)
-                    throws InterruptedException, IOException {
-        return launchSubprocess(null, null, true, testClass, testSelector, runnable, args);
+    /**
+     * Calls {@link #launchSubprocess(Predicate, boolean, Class, String, Runnable, String...)} with
+     * the given args, {@code vmArgsFilter=null} and {@code check=true}.
+     */
+    public static SubprocessUtil.Subprocess launchSubprocess(
+                    Class<? extends GraalCompilerTest> testClass,
+                    String testSelector,
+                    Runnable runnable,
+                    String... extraVmArgs) throws InterruptedException, IOException {
+        return launchSubprocess(null, true, testClass, testSelector, runnable, extraVmArgs);
     }
 
     private static List<String> filter(List<String> args, Predicate<String> vmArgsFilter) {
@@ -106,17 +108,36 @@ private static String getRecursionPropName(Class<? extends GraalCompilerTest> te
         return "test." + testClass.getName() + ".subprocess";
     }
 
-    public static SubprocessUtil.Subprocess launchSubprocess(Predicate<List<String>> testPredicate, Predicate<String> vmArgsFilter, boolean expectNormalExit,
-                    Class<? extends GraalCompilerTest> testClass, String testSelector, Runnable runnable, String... args)
-                    throws InterruptedException, IOException {
+    /**
+     * Launches {@code runnable} in a subprocess.
+     *
+     * @param runnable task to be run in the subprocess
+     * @param vmArgsFilter filters the VM args to only those matching this predicate
+     * @param check if true, and the process exits with a non-zero exit code, an AssertionError
+     *            exception will be thrown
+     * @param testClass the class defining the test
+     * @param testSelector name of the current test. This is typically provided by
+     *            {@link GraalTest#currentUnitTestName()}. Use {@link #ALL_TESTS} to denote that all
+     *            tests in {@code testClass} are to be run.
+     * @param extraVmArgs extra VM args to pass to the subprocess
+     * @return returns {@code null} when run in the subprocess. Outside the subprocess, returns a
+     *         {@link Subprocess} instance describing the process after its successful termination.
+     */
+    public static SubprocessUtil.Subprocess launchSubprocess(
+                    Predicate<String> vmArgsFilter,
+                    boolean check,
+                    Class<? extends GraalCompilerTest> testClass,
+                    String testSelector,
+                    Runnable runnable,
+                    String... extraVmArgs) throws InterruptedException, IOException {
         if (isRecursiveLaunch(testClass)) {
             runnable.run();
             return null;
         } else {
             List<String> vmArgs = withoutDebuggerArguments(getVMCommandLine());
             vmArgs.add(SubprocessUtil.PACKAGE_OPENING_OPTIONS);
             vmArgs.add("-D" + getRecursionPropName(testClass) + "=true");
-            vmArgs.addAll(Arrays.asList(args));
+            vmArgs.addAll(Arrays.asList(extraVmArgs));
             if (vmArgsFilter != null) {
                 vmArgs = filter(vmArgs, vmArgsFilter);
             }
@@ -132,13 +153,9 @@ public static SubprocessUtil.Subprocess launchSubprocess(Predicate<List<String>>
             }
             SubprocessUtil.Subprocess proc = java(vmArgs, mainClassAndArgs);
 
-            if (testPredicate != null && !testPredicate.test(proc.output)) {
-                fail("Subprocess produced unexpected output:%n%s", proc.preserveArgfile());
-            }
             int exitCode = proc.exitCode;
-            if ((exitCode == 0) != expectNormalExit) {
-                String expectExitCode = expectNormalExit ? "0" : "non-0";
-                fail("Subprocess produced exit code %d, but expected %s%n%s", exitCode, expectExitCode, proc.preserveArgfile());
+            if (check && exitCode != 0) {
+                fail("Subprocess produced non-0 exit code %d%n%s", exitCode, proc.preserveArgfile());
             }
 
             // Test passed
@@ -148,5 +165,4 @@ public static SubprocessUtil.Subprocess launchSubprocess(Predicate<List<String>>
             return proc;
         }
     }
-
 }

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/test/GraalOnlyIntrinsicsTest.java

@@ -26,14 +26,14 @@
 
 import java.io.IOException;
 
-import jdk.graal.compiler.core.test.SubprocessTest;
+import org.junit.Test;
+
 import jdk.graal.compiler.api.test.Graal;
+import jdk.graal.compiler.core.test.SubprocessTest;
 import jdk.graal.compiler.hotspot.GraalHotSpotVMConfig;
 import jdk.graal.compiler.hotspot.HotSpotGraalRuntimeProvider;
 import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugin;
 import jdk.graal.compiler.runtime.RuntimeProvider;
-import org.junit.Test;
-
 import jdk.vm.ci.aarch64.AArch64;
 
 /**
@@ -70,7 +70,7 @@ public void testUseCharacterCompareIntrinsics() {
 
     @Test
     public void assertHotSpotFlags() throws IOException, InterruptedException {
-        launchSubprocess(s -> !s.contains("UseVectorizedMismatchIntrinsic"), () -> testUseVectorizedMismatchIntrinsic());
-        launchSubprocess(s -> !s.contains("UseCharacterCompareIntrinsics"), () -> testUseCharacterCompareIntrinsics());
+        launchSubprocess(s -> !s.contains("UseVectorizedMismatchIntrinsic"), true, getClass(), currentUnitTestName(), () -> testUseVectorizedMismatchIntrinsic());
+        launchSubprocess(s -> !s.contains("UseCharacterCompareIntrinsics"), true, getClass(), currentUnitTestName(), () -> testUseCharacterCompareIntrinsics());
     }
 }