8321812: Update GC tests to use execute[Limited]TestJava

Reviewed-by: tschatzl, aboldtch
openjdk · Apr 2, 2024 · 70163bd · 70163bd
1 parent 426dac3
commit 70163bd
Show file tree

Hide file tree

Showing 132 changed files with 478 additions and 671 deletions.
diff --git a/test/hotspot/jtreg/gc/TestAgeOutput.java b/test/hotspot/jtreg/gc/TestAgeOutput.java
@@ -66,7 +66,7 @@ public static void checkPattern(String pattern, String what) throws Exception {
     }
 
     public static void runTest(String gcArg) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             "-Xbootclasspath/a:.",
             "-XX:+UnlockExperimentalVMOptions",
             "-XX:+UnlockDiagnosticVMOptions",
@@ -75,7 +75,6 @@ public static void runTest(String gcArg) throws Exception {
             "-Xmx10M",
             "-Xlog:gc+age=trace",
             GCTest.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
         output.shouldHaveExitValue(0);
 

diff --git a/test/hotspot/jtreg/gc/TestAllocateHeapAt.java b/test/hotspot/jtreg/gc/TestAllocateHeapAt.java
@@ -36,13 +36,12 @@
 
 public class TestAllocateHeapAt {
   public static void main(String args[]) throws Exception {
-    ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
+    OutputAnalyzer output = ProcessTools.executeTestJava(
         "-XX:AllocateHeapAt=" + System.getProperty("test.dir", "."),
         "-Xlog:gc+heap=info",
         "-Xmx32m",
         "-Xms32m",
         "-version");
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
     System.out.println("Output:\n" + output.getOutput());
 

diff --git a/test/hotspot/jtreg/gc/TestAllocateHeapAtError.java b/test/hotspot/jtreg/gc/TestAllocateHeapAtError.java
@@ -45,13 +45,12 @@ public static void main(String args[]) throws Exception {
       f = new File(test_dir, UUID.randomUUID().toString());
     } while(f.exists());
 
-    ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
+    OutputAnalyzer output = ProcessTools.executeTestJava(
         "-XX:AllocateHeapAt=" + f.getName(),
         "-Xlog:gc+heap=info",
         "-Xmx32m",
         "-Xms32m",
         "-version");
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
     System.out.println("Output:\n" + output.getOutput());
 

diff --git a/test/hotspot/jtreg/gc/TestAllocateHeapAtMultiple.java b/test/hotspot/jtreg/gc/TestAllocateHeapAtMultiple.java
@@ -60,8 +60,7 @@ public static void main(String args[]) throws Exception {
                                               "-Xlog:gc+heap=info",
                                               "-version"});
 
-      ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(flags);
-      OutputAnalyzer output = new OutputAnalyzer(pb.start());
+      OutputAnalyzer output = ProcessTools.executeTestJava(flags);
 
       System.out.println("Output:\n" + output.getOutput());
 

diff --git a/test/hotspot/jtreg/gc/TestCardTablePageCommits.java b/test/hotspot/jtreg/gc/TestCardTablePageCommits.java
@@ -42,12 +42,11 @@ public static void main(String args[]) throws Exception {
         // because of 8kB pages, assume 4 KB pages for all other CPUs.
         String Xmx = "-Xmx4m";
 
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             Xmx,
             "-XX:NativeMemoryTracking=detail",
             "-XX:+UseParallelGC",
             "-version");
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldHaveExitValue(0);
     }
 }
diff --git a/test/hotspot/jtreg/gc/TestNumWorkerOutput.java b/test/hotspot/jtreg/gc/TestNumWorkerOutput.java
@@ -58,7 +58,7 @@ public static void checkPatternOnce(String pattern, String what) throws Exceptio
     }
 
     public static void runTest(String gcArg) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             "-Xbootclasspath/a:.",
             "-XX:+UnlockExperimentalVMOptions",
             "-XX:+UnlockDiagnosticVMOptions",
@@ -67,7 +67,6 @@ public static void runTest(String gcArg) throws Exception {
             "-Xmx10M",
             "-XX:+PrintGCDetails",
             GCTest.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
         output.shouldHaveExitValue(0);
 

diff --git a/test/hotspot/jtreg/gc/TestPLABAdaptToMinTLABSize.java b/test/hotspot/jtreg/gc/TestPLABAdaptToMinTLABSize.java
@@ -48,9 +48,7 @@ private static void runTest(boolean shouldSucceed, String... extraArgs) throws E
         Collections.addAll(testArguments, extraArgs);
         testArguments.add("-version");
 
-        ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(testArguments);
-
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeTestJava(testArguments);
 
         System.out.println(output.getStderr());
 

diff --git a/test/hotspot/jtreg/gc/TestSmallHeap.java b/test/hotspot/jtreg/gc/TestSmallHeap.java
@@ -96,12 +96,11 @@ public static void main(String[] args) throws Exception {
 
     private static void verifySmallHeapSize(String gc, long expectedMaxHeap) throws Exception {
         long minMaxHeap = 4 * 1024 * 1024;
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
             gc,
             "-Xmx" + minMaxHeap,
             "-XX:+PrintFlagsFinal",
             VerifyHeapSize.class.getName());
-        OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
         analyzer.shouldHaveExitValue(0);
 
         expectedMaxHeap = Math.max(expectedMaxHeap, minMaxHeap);

diff --git a/test/hotspot/jtreg/gc/TestVerifyDuringStartup.java b/test/hotspot/jtreg/gc/TestVerifyDuringStartup.java
@@ -37,13 +37,12 @@
 
 public class TestVerifyDuringStartup {
   public static void main(String args[]) throws Exception {
-    ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
+    OutputAnalyzer output = ProcessTools.executeTestJava(
         "-XX:-UseTLAB",
         "-XX:+UnlockDiagnosticVMOptions",
         "-XX:+VerifyDuringStartup",
         "-Xlog:gc+verify=debug",
         "-version");
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
     System.out.println("Output:\n" + output.getOutput());
 

diff --git a/test/hotspot/jtreg/gc/TestVerifySilently.java b/test/hotspot/jtreg/gc/TestVerifySilently.java
@@ -57,8 +57,7 @@ private static OutputAnalyzer runTest(boolean verifySilently) throws Exception {
                                              "-XX:+VerifyAfterGC",
                                              (verifySilently ? "-Xlog:gc":"-Xlog:gc+verify=debug"),
                                              TestVerifySilentlyRunSystemGC.class.getName()});
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(vmOpts);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = ProcessTools.executeLimitedTestJava(vmOpts);
 
     System.out.println("Output:\n" + output.getOutput());
     return output;

diff --git a/test/hotspot/jtreg/gc/TestVerifySubSet.java b/test/hotspot/jtreg/gc/TestVerifySubSet.java
@@ -59,8 +59,7 @@ private static OutputAnalyzer runTest(String subset) throws Exception {
                                                  "-Xlog:gc+verify=debug",
                                                  "-XX:VerifySubSet="+subset,
                                                  TestVerifySubSetRunSystemGC.class.getName()});
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(vmOpts);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(vmOpts);
 
         System.out.println("Output:\n" + output.getOutput());
         return output;

diff --git a/test/hotspot/jtreg/gc/arguments/GCArguments.java b/test/hotspot/jtreg/gc/arguments/GCArguments.java
@@ -27,6 +27,7 @@
 import java.util.Collections;
 import java.util.List;
 import jdk.test.lib.Platform;
+import jdk.test.lib.process.OutputAnalyzer;
 import jdk.test.lib.process.ProcessTools;
 
 /**
@@ -81,4 +82,20 @@ static public ProcessBuilder createTestJavaProcessBuilder(List<String> arguments
     static public ProcessBuilder createTestJavaProcessBuilder(String... arguments) {
         return ProcessTools.createTestJavaProcessBuilder(withDefaults(arguments));
     }
+
+    static public OutputAnalyzer executeLimitedTestJava(List<String> arguments) throws Exception {
+        return executeLimitedTestJava(arguments.toArray(String[]::new));
+    }
+
+    static public OutputAnalyzer executeLimitedTestJava(String... arguments) throws Exception {
+        return ProcessTools.executeLimitedTestJava(withDefaults(arguments));
+    }
+
+    static public OutputAnalyzer executeTestJava(List<String> arguments) throws Exception {
+        return executeTestJava(arguments.toArray(String[]::new));
+    }
+
+    static public OutputAnalyzer executeTestJava(String... arguments) throws Exception {
+        return ProcessTools.executeTestJava(withDefaults(arguments));
+    }
 }
diff --git a/test/hotspot/jtreg/gc/arguments/TestAggressiveHeap.java b/test/hotspot/jtreg/gc/arguments/TestAggressiveHeap.java
@@ -65,11 +65,9 @@ public static void main(String args[]) throws Exception {
         " *bool +UseParallelGC *= *true +\\{product\\} *\\{command line\\}";
 
     private static void testFlag() throws Exception {
-        ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(
+        OutputAnalyzer output = GCArguments.executeTestJava(
             option, heapSizeOption, "-XX:+PrintFlagsFinal", "-version");
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
-
         output.shouldHaveExitValue(0);
 
         String value = output.firstMatch(parallelGCPattern);

diff --git a/test/hotspot/jtreg/gc/arguments/TestCompressedClassFlags.java b/test/hotspot/jtreg/gc/arguments/TestCompressedClassFlags.java
@@ -41,17 +41,13 @@
 public class TestCompressedClassFlags {
     public static void main(String[] args) throws Exception {
         if (Platform.is64bit()) {
-            OutputAnalyzer output = runJava("-XX:CompressedClassSpaceSize=1g",
-                                            "-XX:-UseCompressedClassPointers",
-                                            "-version");
+            OutputAnalyzer output = GCArguments.executeTestJava(
+                "-XX:CompressedClassSpaceSize=1g",
+                "-XX:-UseCompressedClassPointers",
+                "-version");
             output.shouldContain("warning");
             output.shouldNotContain("error");
             output.shouldHaveExitValue(0);
         }
     }
-
-    private static OutputAnalyzer runJava(String ... args) throws Exception {
-        ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(args);
-        return new OutputAnalyzer(pb.start());
-    }
 }
diff --git a/test/hotspot/jtreg/gc/arguments/TestDisableDefaultGC.java b/test/hotspot/jtreg/gc/arguments/TestDisableDefaultGC.java
@@ -40,14 +40,13 @@
 public class TestDisableDefaultGC {
     public static void main(String[] args) throws Exception {
         // Start VM, disabling all possible default GCs
-        ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder("-XX:-UseSerialGC",
-                                                                     "-XX:-UseParallelGC",
-                                                                     "-XX:-UseG1GC",
-                                                                     "-XX:-UseZGC",
-                                                                     "-XX:+UnlockExperimentalVMOptions",
-                                                                     "-XX:-UseShenandoahGC",
-                                                                     "-version");
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = GCArguments.executeTestJava("-XX:-UseSerialGC",
+                                                            "-XX:-UseParallelGC",
+                                                            "-XX:-UseG1GC",
+                                                            "-XX:-UseZGC",
+                                                            "-XX:+UnlockExperimentalVMOptions",
+                                                            "-XX:-UseShenandoahGC",
+                                                            "-version");
         output.shouldMatch("Garbage collector not selected");
         output.shouldHaveExitValue(1);
     }

diff --git a/test/hotspot/jtreg/gc/arguments/TestG1ConcMarkStepDurationMillis.java b/test/hotspot/jtreg/gc/arguments/TestG1ConcMarkStepDurationMillis.java
@@ -78,8 +78,7 @@ private static void runG1ConcMarkStepDurationMillisTest(String expectedValue, in
 
     Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:G1ConcMarkStepDurationMillis="+expectedValue, "-XX:+PrintFlagsFinal", "-version");
 
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(vmOpts);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeTestJava(vmOpts);
 
     output.shouldHaveExitValue(expectedResult == PASS ? 0 : 1);
     String stdout = output.getStdout();

diff --git a/test/hotspot/jtreg/gc/arguments/TestG1ConcRefinementThreads.java b/test/hotspot/jtreg/gc/arguments/TestG1ConcRefinementThreads.java
@@ -69,8 +69,7 @@ private static void runG1ConcRefinementThreadsTest(String[] passedOpts,
     }
     Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:+PrintFlagsFinal", "-version");
 
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(vmOpts);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeTestJava(vmOpts);
 
     output.shouldHaveExitValue(0);
     String stdout = output.getStdout();

diff --git a/test/hotspot/jtreg/gc/arguments/TestG1HeapRegionSize.java b/test/hotspot/jtreg/gc/arguments/TestG1HeapRegionSize.java
@@ -53,8 +53,7 @@ private static void checkG1HeapRegionSize(String[] flags, int expectedValue, int
     flagList.add("-XX:+PrintFlagsFinal");
     flagList.add("-version");
 
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(flagList);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeTestJava(flagList);
     output.shouldHaveExitValue(exitValue);
 
     if (exitValue == 0) {

diff --git a/test/hotspot/jtreg/gc/arguments/TestG1PercentageOptions.java b/test/hotspot/jtreg/gc/arguments/TestG1PercentageOptions.java
@@ -63,8 +63,7 @@ private static final class OptionDescription {
     };
 
     private static void check(String flag, boolean is_valid) throws Exception {
-        ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder("-XX:+UseG1GC", flag, "-version");
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = GCArguments.executeTestJava("-XX:+UseG1GC", flag, "-version");
         if (is_valid) {
             output.shouldHaveExitValue(0);
         } else {

diff --git a/test/hotspot/jtreg/gc/arguments/TestG1RemSetFlags.java b/test/hotspot/jtreg/gc/arguments/TestG1RemSetFlags.java
@@ -48,8 +48,7 @@ private static void checkG1RemSetFlags(String[] flags, int exitValue) throws Exc
     flagList.add("-XX:+PrintFlagsFinal");
     flagList.add("-version");
 
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(flagList);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeTestJava(flagList);
     output.shouldHaveExitValue(exitValue);
   }
 

diff --git a/test/hotspot/jtreg/gc/arguments/TestHeapFreeRatio.java b/test/hotspot/jtreg/gc/arguments/TestHeapFreeRatio.java
@@ -48,11 +48,10 @@ enum Validation {
   }
 
   private static void testMinMaxFreeRatio(String min, String max, Validation type) throws Exception {
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(
+    OutputAnalyzer output = GCArguments.executeTestJava(
         "-Xminf" + min,
         "-Xmaxf" + max,
         "-version");
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
     switch (type) {
     case VALID:

diff --git a/test/hotspot/jtreg/gc/arguments/TestInitialTenuringThreshold.java b/test/hotspot/jtreg/gc/arguments/TestInitialTenuringThreshold.java
@@ -41,14 +41,13 @@
 public class TestInitialTenuringThreshold {
 
   public static void runWithThresholds(int initial, int max, boolean shouldfail) throws Exception {
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(
+    OutputAnalyzer output = GCArguments.executeTestJava(
       "-XX:+UseParallelGC",
       "-XX:InitialTenuringThreshold=" + String.valueOf(initial),
       "-XX:MaxTenuringThreshold=" + String.valueOf(max),
       "-version"
       );
 
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
     if (shouldfail) {
       output.shouldHaveExitValue(1);
     } else {
@@ -58,14 +57,13 @@ public static void runWithThresholds(int initial, int max, boolean shouldfail) t
 
 
   public static void main(String args[]) throws Exception {
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(
+    OutputAnalyzer output = GCArguments.executeTestJava(
       // some value below the default value of InitialTenuringThreshold of 7
       "-XX:+UseParallelGC",
       "-XX:MaxTenuringThreshold=1",
       "-version"
       );
 
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
     output.shouldHaveExitValue(0);
     // successful tests
     runWithThresholds(0, 10, false);

diff --git a/test/hotspot/jtreg/gc/arguments/TestMaxHeapSizeTools.java b/test/hotspot/jtreg/gc/arguments/TestMaxHeapSizeTools.java
@@ -115,9 +115,8 @@ private static long align_up(long value, long alignment) {
   }
 
   private static void getNewOldSize(String gcflag, long[] values) throws Exception {
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(gcflag,
+    OutputAnalyzer output = GCArguments.executeTestJava(gcflag,
       "-XX:+PrintFlagsFinal", "-version");
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
     output.shouldHaveExitValue(0);
 
     String stdout = output.getStdout();
@@ -208,8 +207,7 @@ public static OutputAnalyzer runWhiteBoxTest(String[] vmargs, String classname,
     finalargs.add(classname);
     finalargs.addAll(Arrays.asList(arguments));
 
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(finalargs.toArray(String[]::new));
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeTestJava(finalargs.toArray(String[]::new));
     output.shouldHaveExitValue(0);
 
     return output;
@@ -308,8 +306,7 @@ private static void shouldContainOrNot(OutputAnalyzer output, boolean contains,
   }
 
   private static void expect(String[] flags, boolean hasWarning, boolean hasError, int errorcode) throws Exception {
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(flags);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeTestJava(flags);
     shouldContainOrNot(output, hasWarning, "Warning");
     shouldContainOrNot(output, hasError, "Error");
     output.shouldHaveExitValue(errorcode);

diff --git a/test/hotspot/jtreg/gc/arguments/TestMaxMinHeapFreeRatioFlags.java b/test/hotspot/jtreg/gc/arguments/TestMaxMinHeapFreeRatioFlags.java
@@ -98,8 +98,7 @@ public static void positiveTest(int minRatio, boolean useXminf,
                 Boolean.toString(shrinkHeapInSteps)
         );
 
-        ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
+        OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
         analyzer.shouldHaveExitValue(0);
     }
 
@@ -123,8 +122,7 @@ public static void negativeTest(int minRatio, boolean useXminf,
                 "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED",
                 "-version"
         );
-        ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
+        OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
         analyzer.shouldHaveExitValue(1);
         analyzer.shouldContain("Error: Could not create the Java Virtual Machine.");
     }

diff --git a/test/hotspot/jtreg/gc/arguments/TestMaxNewSize.java b/test/hotspot/jtreg/gc/arguments/TestMaxNewSize.java
@@ -95,8 +95,7 @@ private static String getMaxNewSize(String[] flags) throws Exception {
     finalargs.add("-XX:+PrintFlagsFinal");
     finalargs.add("-version");
 
-    ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(finalargs);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeTestJava(finalargs);
     output.shouldHaveExitValue(0);
     String stdout = output.getStdout();
     return getFlagValue("MaxNewSize", stdout);