diff --git a/test/hotspot/jtreg/gc/TestAgeOutput.java b/test/hotspot/jtreg/gc/TestAgeOutput.java
index fa4445e34bb..cbee132a0af 100644
--- a/test/hotspot/jtreg/gc/TestAgeOutput.java
+++ b/test/hotspot/jtreg/gc/TestAgeOutput.java
@@ -66,7 +66,7 @@ public class TestAgeOutput {
     }
 
     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 class TestAgeOutput {
             "-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
index 8daf0bbcdc7..d1e96751ab8 100644
--- a/test/hotspot/jtreg/gc/TestAllocateHeapAt.java
+++ b/test/hotspot/jtreg/gc/TestAllocateHeapAt.java
@@ -36,13 +36,12 @@ import jdk.test.lib.process.OutputAnalyzer;
 
 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
index 372437b8898..28e2f71d09d 100644
--- a/test/hotspot/jtreg/gc/TestAllocateHeapAtError.java
+++ b/test/hotspot/jtreg/gc/TestAllocateHeapAtError.java
@@ -45,13 +45,12 @@ public class TestAllocateHeapAtError {
       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
index b2d2f1e429d..d8d1b4bd88d 100644
--- a/test/hotspot/jtreg/gc/TestAllocateHeapAtMultiple.java
+++ b/test/hotspot/jtreg/gc/TestAllocateHeapAtMultiple.java
@@ -60,8 +60,7 @@ public class TestAllocateHeapAtMultiple {
                                               "-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
index c468a771076..6c10dd0100e 100644
--- a/test/hotspot/jtreg/gc/TestCardTablePageCommits.java
+++ b/test/hotspot/jtreg/gc/TestCardTablePageCommits.java
@@ -42,12 +42,11 @@ public class TestCardTablePageCommits {
         // 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
index fd48c5a85d0..c4c0dce0c99 100644
--- a/test/hotspot/jtreg/gc/TestNumWorkerOutput.java
+++ b/test/hotspot/jtreg/gc/TestNumWorkerOutput.java
@@ -58,7 +58,7 @@ public class TestNumWorkerOutput {
     }
 
     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 class TestNumWorkerOutput {
             "-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
index c5c4854946d..8dfefcb7d95 100644
--- a/test/hotspot/jtreg/gc/TestPLABAdaptToMinTLABSize.java
+++ b/test/hotspot/jtreg/gc/TestPLABAdaptToMinTLABSize.java
@@ -48,9 +48,7 @@ public class TestPLABAdaptToMinTLABSize {
         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
index a9b32eb81c8..fd6c5860f01 100644
--- a/test/hotspot/jtreg/gc/TestSmallHeap.java
+++ b/test/hotspot/jtreg/gc/TestSmallHeap.java
@@ -96,12 +96,11 @@ public class TestSmallHeap {
 
     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
index 4ad9f9675d9..e651295d5b5 100644
--- a/test/hotspot/jtreg/gc/TestVerifyDuringStartup.java
+++ b/test/hotspot/jtreg/gc/TestVerifyDuringStartup.java
@@ -37,13 +37,12 @@ import jdk.test.lib.process.OutputAnalyzer;
 
 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
index b7b07a1eb8e..2f245f5eed2 100644
--- a/test/hotspot/jtreg/gc/TestVerifySilently.java
+++ b/test/hotspot/jtreg/gc/TestVerifySilently.java
@@ -57,8 +57,7 @@ public class TestVerifySilently {
                                              "-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
index 5aa8cc3eb13..08cddc74a00 100644
--- a/test/hotspot/jtreg/gc/TestVerifySubSet.java
+++ b/test/hotspot/jtreg/gc/TestVerifySubSet.java
@@ -59,8 +59,7 @@ public class TestVerifySubSet {
                                                  "-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
index c59a14954bf..3908ce17966 100644
--- a/test/hotspot/jtreg/gc/arguments/GCArguments.java
+++ b/test/hotspot/jtreg/gc/arguments/GCArguments.java
@@ -27,6 +27,7 @@ import java.util.ArrayList;
 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 @@ public final class GCArguments {
     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
index d01773fd711..4ed673a40fe 100644
--- a/test/hotspot/jtreg/gc/arguments/TestAggressiveHeap.java
+++ b/test/hotspot/jtreg/gc/arguments/TestAggressiveHeap.java
@@ -65,11 +65,9 @@ public class TestAggressiveHeap {
         " *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
index 0b6dce0fc0e..c1975d6b692 100644
--- a/test/hotspot/jtreg/gc/arguments/TestCompressedClassFlags.java
+++ b/test/hotspot/jtreg/gc/arguments/TestCompressedClassFlags.java
@@ -41,17 +41,13 @@ import jdk.test.lib.Platform;
 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
index e8e4552da01..0828622fa7a 100644
--- a/test/hotspot/jtreg/gc/arguments/TestDisableDefaultGC.java
+++ b/test/hotspot/jtreg/gc/arguments/TestDisableDefaultGC.java
@@ -40,14 +40,13 @@ import jdk.test.lib.process.OutputAnalyzer;
 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
index 21a4eddb410..c5f595e7a1a 100644
--- a/test/hotspot/jtreg/gc/arguments/TestG1ConcMarkStepDurationMillis.java
+++ b/test/hotspot/jtreg/gc/arguments/TestG1ConcMarkStepDurationMillis.java
@@ -78,8 +78,7 @@ public class TestG1ConcMarkStepDurationMillis {
 
     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
index 91be97782f5..f82d2b31711 100644
--- a/test/hotspot/jtreg/gc/arguments/TestG1ConcRefinementThreads.java
+++ b/test/hotspot/jtreg/gc/arguments/TestG1ConcRefinementThreads.java
@@ -69,8 +69,7 @@ public class TestG1ConcRefinementThreads {
     }
     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
index 0d63dec0c26..5ecd27e24e8 100644
--- a/test/hotspot/jtreg/gc/arguments/TestG1HeapRegionSize.java
+++ b/test/hotspot/jtreg/gc/arguments/TestG1HeapRegionSize.java
@@ -53,8 +53,7 @@ public class TestG1HeapRegionSize {
     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
index 875e995374a..e8ee2598c9a 100644
--- a/test/hotspot/jtreg/gc/arguments/TestG1PercentageOptions.java
+++ b/test/hotspot/jtreg/gc/arguments/TestG1PercentageOptions.java
@@ -63,8 +63,7 @@ public class TestG1PercentageOptions {
     };
 
     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
index 84483f39272..63b9d782c06 100644
--- a/test/hotspot/jtreg/gc/arguments/TestG1RemSetFlags.java
+++ b/test/hotspot/jtreg/gc/arguments/TestG1RemSetFlags.java
@@ -48,8 +48,7 @@ public class TestG1RemSetFlags {
     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
index 19ecb181418..c8eaa0f46e3 100644
--- a/test/hotspot/jtreg/gc/arguments/TestHeapFreeRatio.java
+++ b/test/hotspot/jtreg/gc/arguments/TestHeapFreeRatio.java
@@ -48,11 +48,10 @@ public class TestHeapFreeRatio {
   }
 
   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
index 7bf78a001bf..07a9065cee1 100644
--- a/test/hotspot/jtreg/gc/arguments/TestInitialTenuringThreshold.java
+++ b/test/hotspot/jtreg/gc/arguments/TestInitialTenuringThreshold.java
@@ -41,14 +41,13 @@ import jdk.test.lib.process.OutputAnalyzer;
 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 class TestInitialTenuringThreshold {
 
 
   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
index 3a5d472f9f8..5af005063c1 100644
--- a/test/hotspot/jtreg/gc/arguments/TestMaxHeapSizeTools.java
+++ b/test/hotspot/jtreg/gc/arguments/TestMaxHeapSizeTools.java
@@ -115,9 +115,8 @@ class TestMaxHeapSizeTools {
   }
 
   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 @@ class TestMaxHeapSizeTools {
     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 @@ class TestMaxHeapSizeTools {
   }
 
   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
index 7e91fe60cfb..11729aa5827 100644
--- a/test/hotspot/jtreg/gc/arguments/TestMaxMinHeapFreeRatioFlags.java
+++ b/test/hotspot/jtreg/gc/arguments/TestMaxMinHeapFreeRatioFlags.java
@@ -98,8 +98,7 @@ public class TestMaxMinHeapFreeRatioFlags {
                 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 class TestMaxMinHeapFreeRatioFlags {
                 "--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
index f2214b8b0cf..ff6c3127640 100644
--- a/test/hotspot/jtreg/gc/arguments/TestMaxNewSize.java
+++ b/test/hotspot/jtreg/gc/arguments/TestMaxNewSize.java
@@ -95,8 +95,7 @@ public class TestMaxNewSize {
     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);
diff --git a/test/hotspot/jtreg/gc/arguments/TestMaxRAMFlags.java b/test/hotspot/jtreg/gc/arguments/TestMaxRAMFlags.java
index 4c66afd5cf5..13bb36ecc43 100644
--- a/test/hotspot/jtreg/gc/arguments/TestMaxRAMFlags.java
+++ b/test/hotspot/jtreg/gc/arguments/TestMaxRAMFlags.java
@@ -61,8 +61,7 @@ public class TestMaxRAMFlags {
     args.add("-XX:+PrintFlagsFinal");
     args.add("-version");
 
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(args);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeLimitedTestJava(args);
     output.shouldHaveExitValue(0);
     String stdout = output.getStdout();
 
@@ -84,8 +83,7 @@ public class TestMaxRAMFlags {
     args.add("-XX:+PrintFlagsFinal");
     args.add("-version");
 
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(args);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeLimitedTestJava(args);
     output.shouldHaveExitValue(0);
     String stdout = output.getStdout();
     return (new Long(getFlagValue("HeapBaseMinAddress", stdout)).longValue());
diff --git a/test/hotspot/jtreg/gc/arguments/TestMinAndInitialSurvivorRatioFlags.java b/test/hotspot/jtreg/gc/arguments/TestMinAndInitialSurvivorRatioFlags.java
index 83f564b98a5..d3a51c40b61 100644
--- a/test/hotspot/jtreg/gc/arguments/TestMinAndInitialSurvivorRatioFlags.java
+++ b/test/hotspot/jtreg/gc/arguments/TestMinAndInitialSurvivorRatioFlags.java
@@ -102,8 +102,7 @@ public class TestMinAndInitialSurvivorRatioFlags {
                 Boolean.toString(useAdaptiveSizePolicy)
         );
         vmOptions.removeIf((String p) -> p.isEmpty());
-        ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
+        OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
         analyzer.shouldHaveExitValue(0);
     }
 
diff --git a/test/hotspot/jtreg/gc/arguments/TestNewRatioFlag.java b/test/hotspot/jtreg/gc/arguments/TestNewRatioFlag.java
index 9076005fa86..6eff65f3fa8 100644
--- a/test/hotspot/jtreg/gc/arguments/TestNewRatioFlag.java
+++ b/test/hotspot/jtreg/gc/arguments/TestNewRatioFlag.java
@@ -82,8 +82,7 @@ public class TestNewRatioFlag {
                 Integer.toString(ratio)
         );
 
-        ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
+        OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
         analyzer.shouldHaveExitValue(0);
         System.out.println(analyzer.getOutput());
     }
diff --git a/test/hotspot/jtreg/gc/arguments/TestNewSizeFlags.java b/test/hotspot/jtreg/gc/arguments/TestNewSizeFlags.java
index 3c3aff980dd..8fc522f8be8 100644
--- a/test/hotspot/jtreg/gc/arguments/TestNewSizeFlags.java
+++ b/test/hotspot/jtreg/gc/arguments/TestNewSizeFlags.java
@@ -133,7 +133,7 @@ public class TestNewSizeFlags {
             long heapSize, long maxHeapSize,
             long expectedNewSize, long expectedMaxNewSize,
             LinkedList<String> options, boolean failureExpected) throws Exception {
-        OutputAnalyzer analyzer = startVM(options, newSize, maxNewSize, heapSize, maxHeapSize, expectedNewSize, expectedMaxNewSize);
+        OutputAnalyzer analyzer = executeLimitedTestJava(options, newSize, maxNewSize, heapSize, maxHeapSize, expectedNewSize, expectedMaxNewSize);
 
         if (failureExpected) {
             analyzer.shouldHaveExitValue(1);
@@ -144,7 +144,7 @@ public class TestNewSizeFlags {
         }
     }
 
-    private static OutputAnalyzer startVM(LinkedList<String> options,
+    private static OutputAnalyzer executeLimitedTestJava(LinkedList<String> options,
             long newSize, long maxNewSize,
             long heapSize, long maxHeapSize,
             long expectedNewSize, long expectedMaxNewSize) throws Exception, IOException {
@@ -166,9 +166,7 @@ public class TestNewSizeFlags {
                 Long.toString(maxHeapSize)
         );
         vmOptions.removeIf(String::isEmpty);
-        ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
-        return analyzer;
+        return GCArguments.executeLimitedTestJava(vmOptions);
     }
 
     /**
diff --git a/test/hotspot/jtreg/gc/arguments/TestNewSizeThreadIncrease.java b/test/hotspot/jtreg/gc/arguments/TestNewSizeThreadIncrease.java
index 82e98429100..583176dfc69 100644
--- a/test/hotspot/jtreg/gc/arguments/TestNewSizeThreadIncrease.java
+++ b/test/hotspot/jtreg/gc/arguments/TestNewSizeThreadIncrease.java
@@ -65,14 +65,13 @@ public class TestNewSizeThreadIncrease {
   }
 
   static void runNewSizeThreadIncreaseTest(String expectedValue, boolean isNewsizeChanged) throws Exception {
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder("-XX:+UseSerialGC",
-                                                                        "-Xms96M",
-                                                                        "-Xmx128M",
-                                                                        "-XX:NewRatio=2",
-                                                                        "-Xlog:gc+heap+ergo=debug",
-                                                                        "-XX:NewSizeThreadIncrease="+expectedValue,
-                                                                        GCTest.class.getName());
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeLimitedTestJava("-XX:+UseSerialGC",
+                                                               "-Xms96M",
+                                                               "-Xmx128M",
+                                                               "-XX:NewRatio=2",
+                                                               "-Xlog:gc+heap+ergo=debug",
+                                                               "-XX:NewSizeThreadIncrease="+expectedValue,
+                                                               GCTest.class.getName());
 
     output.shouldHaveExitValue(0);
 
diff --git a/test/hotspot/jtreg/gc/arguments/TestObjectTenuringFlags.java b/test/hotspot/jtreg/gc/arguments/TestObjectTenuringFlags.java
index ca45def0b2b..ee1e73f9550 100644
--- a/test/hotspot/jtreg/gc/arguments/TestObjectTenuringFlags.java
+++ b/test/hotspot/jtreg/gc/arguments/TestObjectTenuringFlags.java
@@ -161,8 +161,7 @@ public class TestObjectTenuringFlags {
     }
     Collections.addAll(vmOpts, "-XX:+UseParallelGC", "-XX:+PrintFlagsFinal", "-version");
 
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(vmOpts);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeLimitedTestJava(vmOpts);
 
     if (shouldFail) {
       output.shouldHaveExitValue(1);
diff --git a/test/hotspot/jtreg/gc/arguments/TestParallelGCThreads.java b/test/hotspot/jtreg/gc/arguments/TestParallelGCThreads.java
index 1055f4fee13..8cc3292b25f 100644
--- a/test/hotspot/jtreg/gc/arguments/TestParallelGCThreads.java
+++ b/test/hotspot/jtreg/gc/arguments/TestParallelGCThreads.java
@@ -56,10 +56,9 @@ public class TestParallelGCThreads {
   private static final String printFlagsFinalPattern = " *uint *" + flagName + " *:?= *(\\d+) *\\{product\\} *";
 
   public static void testDefaultValue()  throws Exception {
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(
+    OutputAnalyzer output = GCArguments.executeLimitedTestJava(
       "-XX:+UnlockExperimentalVMOptions", "-XX:+PrintFlagsFinal", "-version");
 
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
     String value = output.firstMatch(printFlagsFinalPattern, 1);
 
     try {
@@ -94,12 +93,11 @@ public class TestParallelGCThreads {
 
     for (String gc : supportedGC) {
       // Make sure the VM does not allow ParallelGCThreads set to 0
-      ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(
+      OutputAnalyzer output = GCArguments.executeLimitedTestJava(
           "-XX:+Use" + gc + "GC",
           "-XX:ParallelGCThreads=0",
           "-XX:+PrintFlagsFinal",
           "-version");
-      OutputAnalyzer output = new OutputAnalyzer(pb.start());
       output.shouldHaveExitValue(1);
 
       // Do some basic testing to ensure the flag updates the count
@@ -124,8 +122,7 @@ public class TestParallelGCThreads {
   }
 
   public static long getParallelGCThreadCount(String... flags) throws Exception {
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(flags);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeLimitedTestJava(flags);
     output.shouldHaveExitValue(0);
     String stdout = output.getStdout();
     return FlagsValue.getFlagLongValue("ParallelGCThreads", stdout);
diff --git a/test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java b/test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java
index d47d277e30b..40dfc4dc7fb 100644
--- a/test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java
+++ b/test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java
@@ -77,9 +77,7 @@ public class TestParallelRefProc {
         result.addAll(Arrays.asList(args));
         result.add("-XX:+PrintFlagsFinal");
         result.add("-version");
-        ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(result);
-
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = GCArguments.executeLimitedTestJava(result);
 
         output.shouldHaveExitValue(0);
 
diff --git a/test/hotspot/jtreg/gc/arguments/TestSelectDefaultGC.java b/test/hotspot/jtreg/gc/arguments/TestSelectDefaultGC.java
index a48f21c957b..fb4787f452f 100644
--- a/test/hotspot/jtreg/gc/arguments/TestSelectDefaultGC.java
+++ b/test/hotspot/jtreg/gc/arguments/TestSelectDefaultGC.java
@@ -44,12 +44,11 @@ public class TestSelectDefaultGC {
 
     public static void testDefaultGC(boolean actAsServer) throws Exception {
         // Start VM without specifying GC
-        ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = GCArguments.executeLimitedTestJava(
             "-XX:" + (actAsServer ? "+" : "-") + "AlwaysActAsServerClassMachine",
             "-XX:" + (actAsServer ? "-" : "+") + "NeverActAsServerClassMachine",
             "-XX:+PrintFlagsFinal",
             "-version");
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldHaveExitValue(0);
 
         final boolean isServer = actAsServer;
diff --git a/test/hotspot/jtreg/gc/arguments/TestSmallInitialHeapWithLargePageAndNUMA.java b/test/hotspot/jtreg/gc/arguments/TestSmallInitialHeapWithLargePageAndNUMA.java
index 779a5d8b537..f517e094edd 100644
--- a/test/hotspot/jtreg/gc/arguments/TestSmallInitialHeapWithLargePageAndNUMA.java
+++ b/test/hotspot/jtreg/gc/arguments/TestSmallInitialHeapWithLargePageAndNUMA.java
@@ -60,14 +60,13 @@ public class TestSmallInitialHeapWithLargePageAndNUMA {
     long initHeap = heapAlignment;
     long maxHeap = heapAlignment * 2;
 
-    ProcessBuilder pb_enabled = GCArguments.createLimitedTestJavaProcessBuilder(
+    OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(
         "-XX:+UseParallelGC",
         "-Xms" + String.valueOf(initHeap),
         "-Xmx" + String.valueOf(maxHeap),
         "-XX:+UseNUMA",
         "-XX:+PrintFlagsFinal",
         "-version");
-    OutputAnalyzer analyzer = new OutputAnalyzer(pb_enabled.start());
 
     if (largePageOrNumaEnabled(analyzer)) {
       // We reach here, if both NUMA and HugeTLB are supported.
diff --git a/test/hotspot/jtreg/gc/arguments/TestSurvivorRatioFlag.java b/test/hotspot/jtreg/gc/arguments/TestSurvivorRatioFlag.java
index 8567615220a..a593970e6f7 100644
--- a/test/hotspot/jtreg/gc/arguments/TestSurvivorRatioFlag.java
+++ b/test/hotspot/jtreg/gc/arguments/TestSurvivorRatioFlag.java
@@ -87,8 +87,7 @@ public class TestSurvivorRatioFlag {
                 Integer.toString(ratio)
         );
 
-        ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
+        OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
         analyzer.shouldHaveExitValue(0);
     }
 
diff --git a/test/hotspot/jtreg/gc/arguments/TestTargetSurvivorRatioFlag.java b/test/hotspot/jtreg/gc/arguments/TestTargetSurvivorRatioFlag.java
index 8f8b4aa1087..afe424896b5 100644
--- a/test/hotspot/jtreg/gc/arguments/TestTargetSurvivorRatioFlag.java
+++ b/test/hotspot/jtreg/gc/arguments/TestTargetSurvivorRatioFlag.java
@@ -116,8 +116,7 @@ public class TestTargetSurvivorRatioFlag {
         vmOptions.add("-XX:TargetSurvivorRatio=" + ratio);
         vmOptions.add("-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.");
@@ -151,8 +150,7 @@ public class TestTargetSurvivorRatioFlag {
                 Integer.toString(ratio)
         );
 
-        ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
+        OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
 
         analyzer.shouldHaveExitValue(0);
 
diff --git a/test/hotspot/jtreg/gc/arguments/TestUnrecognizedVMOptionsHandling.java b/test/hotspot/jtreg/gc/arguments/TestUnrecognizedVMOptionsHandling.java
index 24da380298b..f944c0c4e74 100644
--- a/test/hotspot/jtreg/gc/arguments/TestUnrecognizedVMOptionsHandling.java
+++ b/test/hotspot/jtreg/gc/arguments/TestUnrecognizedVMOptionsHandling.java
@@ -40,32 +40,29 @@ public class TestUnrecognizedVMOptionsHandling {
 
   public static void main(String args[]) throws Exception {
     // The first two JAVA processes are expected to fail, but with a correct VM option suggestion
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(
+    OutputAnalyzer outputWithError = GCArguments.executeLimitedTestJava(
       "-XX:+UseDynamicNumberOfGcThreads",
       "-version"
       );
-    OutputAnalyzer outputWithError = new OutputAnalyzer(pb.start());
     outputWithError.shouldContain("Did you mean '(+/-)UseDynamicNumberOfGCThreads'?");
     if (outputWithError.getExitValue() == 0) {
       throw new RuntimeException("Not expected to get exit value 0");
     }
 
-    pb = GCArguments.createLimitedTestJavaProcessBuilder(
+    outputWithError = GCArguments.executeLimitedTestJava(
       "-XX:MaxiumHeapSize=500m",
       "-version"
       );
-    outputWithError = new OutputAnalyzer(pb.start());
     outputWithError.shouldContain("Did you mean 'MaxHeapSize=<value>'?");
     if (outputWithError.getExitValue() == 0) {
       throw new RuntimeException("Not expected to get exit value 0");
     }
 
     // The last JAVA process should run successfully for the purpose of sanity check
-    pb = GCArguments.createLimitedTestJavaProcessBuilder(
+    OutputAnalyzer outputWithNoError = GCArguments.executeLimitedTestJava(
       "-XX:+UseDynamicNumberOfGCThreads",
       "-version"
       );
-    OutputAnalyzer outputWithNoError = new OutputAnalyzer(pb.start());
     outputWithNoError.shouldNotContain("Did you mean '(+/-)UseDynamicNumberOfGCThreads'?");
     outputWithNoError.shouldHaveExitValue(0);
   }
diff --git a/test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsErgoTools.java b/test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsErgoTools.java
index 19ebdea3c0e..2a1d2fef879 100644
--- a/test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsErgoTools.java
+++ b/test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsErgoTools.java
@@ -93,8 +93,7 @@ class TestUseCompressedOopsErgoTools {
     finalargs.add(classname);
     finalargs.addAll(Arrays.asList(arguments));
 
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(finalargs);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeLimitedTestJava(finalargs);
     output.shouldHaveExitValue(0);
     return output;
   }
@@ -157,8 +156,7 @@ class TestUseCompressedOopsErgoTools {
   }
 
   private static String expect(String[] flags, boolean hasWarning, boolean hasError, int errorcode) throws Exception {
-    ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(flags);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = GCArguments.executeLimitedTestJava(flags);
     output.shouldHaveExitValue(errorcode);
     return output.getStdout();
   }
diff --git a/test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsFlagsWithUlimit.java b/test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsFlagsWithUlimit.java
index 07cf4126970..495b36407b1 100644
--- a/test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsFlagsWithUlimit.java
+++ b/test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsFlagsWithUlimit.java
@@ -59,9 +59,8 @@ public class TestUseCompressedOopsFlagsWithUlimit {
     // Convert bytes to kbytes for ulimit -v
     var ulimit_prefix = "ulimit -v " + (ulimit / 1024);
 
-    String cmd = ProcessTools.getCommandLine(ProcessTools.createTestJavaProcessBuilder(args.toArray(String[]::new)));
-    ProcessBuilder pb = new ProcessBuilder("sh", "-c", ulimit_prefix + ";" + cmd);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    String cmd = ProcessTools.getCommandLine(ProcessTools.createTestJavaProcessBuilder(args));
+    OutputAnalyzer output = ProcessTools.executeProcess("sh", "-c", ulimit_prefix + ";" + cmd);
     output.shouldHaveExitValue(0);
     String stdout = output.getStdout();
 
diff --git a/test/hotspot/jtreg/gc/arguments/TestUseNUMAInterleaving.java b/test/hotspot/jtreg/gc/arguments/TestUseNUMAInterleaving.java
index 4a7fb7108c3..29c13f1fd90 100644
--- a/test/hotspot/jtreg/gc/arguments/TestUseNUMAInterleaving.java
+++ b/test/hotspot/jtreg/gc/arguments/TestUseNUMAInterleaving.java
@@ -39,11 +39,10 @@ import jdk.test.lib.process.OutputAnalyzer;
 public class TestUseNUMAInterleaving {
 
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(
+        OutputAnalyzer output = GCArguments.executeTestJava(
             "-XX:+UseNUMA",
             "-XX:+PrintFlagsFinal",
             "-version");
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
         boolean isNUMAEnabled
                 = Boolean.parseBoolean(output.firstMatch(NUMA_FLAG_PATTERN, 1));
diff --git a/test/hotspot/jtreg/gc/arguments/TestVerifyBeforeAndAfterGCFlags.java b/test/hotspot/jtreg/gc/arguments/TestVerifyBeforeAndAfterGCFlags.java
index a3d6d5a7440..cc1f9be6fb7 100644
--- a/test/hotspot/jtreg/gc/arguments/TestVerifyBeforeAndAfterGCFlags.java
+++ b/test/hotspot/jtreg/gc/arguments/TestVerifyBeforeAndAfterGCFlags.java
@@ -99,8 +99,7 @@ public class TestVerifyBeforeAndAfterGCFlags {
                                                       : "-XX:-VerifyAfterGC"),
                                        GarbageProducer.class.getName(),
                                        doFullGC ? "t" : "f" });
-        ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(vmOpts);
-        OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
+        OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOpts);
 
         analyzer.shouldHaveExitValue(0);
         analyzer.shouldNotMatch(VERIFY_BEFORE_GC_CORRUPTED_PATTERN);
diff --git a/test/hotspot/jtreg/gc/class_unloading/TestG1ClassUnloadingHWM.java b/test/hotspot/jtreg/gc/class_unloading/TestG1ClassUnloadingHWM.java
index 238e747fb1e..9af3baf87b3 100644
--- a/test/hotspot/jtreg/gc/class_unloading/TestG1ClassUnloadingHWM.java
+++ b/test/hotspot/jtreg/gc/class_unloading/TestG1ClassUnloadingHWM.java
@@ -45,7 +45,7 @@ public class TestG1ClassUnloadingHWM {
   private static long YoungGenSize  = 32 * 1024 * 1024;
 
   private static OutputAnalyzer run(boolean enableUnloading) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+    return ProcessTools.executeLimitedTestJava(
       "-Xbootclasspath/a:.",
       "-XX:+UnlockDiagnosticVMOptions",
       "-XX:+WhiteBoxAPI",
@@ -57,7 +57,6 @@ public class TestG1ClassUnloadingHWM {
       TestG1ClassUnloadingHWM.AllocateBeyondMetaspaceSize.class.getName(),
       "" + MetaspaceSize,
       "" + YoungGenSize);
-    return new OutputAnalyzer(pb.start());
   }
 
   public static OutputAnalyzer runWithG1ClassUnloading() throws Exception {
diff --git a/test/hotspot/jtreg/gc/epsilon/TestDieDefault.java b/test/hotspot/jtreg/gc/epsilon/TestDieDefault.java
index c978f149fca..016bb517c3c 100644
--- a/test/hotspot/jtreg/gc/epsilon/TestDieDefault.java
+++ b/test/hotspot/jtreg/gc/epsilon/TestDieDefault.java
@@ -37,15 +37,13 @@ import jdk.test.lib.process.ProcessTools;
 public class TestDieDefault {
 
   public static void passWith(String... args) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args);
-    OutputAnalyzer out = new OutputAnalyzer(pb.start());
+    OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
     out.shouldNotContain("OutOfMemoryError");
     out.shouldHaveExitValue(0);
   }
 
   public static void failWith(String... args) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args);
-    OutputAnalyzer out = new OutputAnalyzer(pb.start());
+    OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
     out.shouldContain("OutOfMemoryError");
     if (out.getExitValue() == 0) {
       throw new IllegalStateException("Should have failed with non-zero exit code");
diff --git a/test/hotspot/jtreg/gc/epsilon/TestDieWithHeapDump.java b/test/hotspot/jtreg/gc/epsilon/TestDieWithHeapDump.java
index 2e19141d286..8f6e9a36d77 100644
--- a/test/hotspot/jtreg/gc/epsilon/TestDieWithHeapDump.java
+++ b/test/hotspot/jtreg/gc/epsilon/TestDieWithHeapDump.java
@@ -38,8 +38,7 @@ import jdk.test.lib.process.ProcessTools;
 public class TestDieWithHeapDump {
 
   public static void passWith(String... args) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args);
-    OutputAnalyzer out = new OutputAnalyzer(pb.start());
+    OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
     out.shouldNotContain("OutOfMemoryError");
     out.shouldHaveExitValue(0);
   }
diff --git a/test/hotspot/jtreg/gc/epsilon/TestDieWithOnError.java b/test/hotspot/jtreg/gc/epsilon/TestDieWithOnError.java
index a6593fecdff..7be60c59595 100644
--- a/test/hotspot/jtreg/gc/epsilon/TestDieWithOnError.java
+++ b/test/hotspot/jtreg/gc/epsilon/TestDieWithOnError.java
@@ -39,16 +39,14 @@ public class TestDieWithOnError {
   static String ON_ERR_MSG = "Epsilon error handler message";
 
   public static void passWith(String... args) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args);
-    OutputAnalyzer out = new OutputAnalyzer(pb.start());
+    OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
     out.shouldNotContain("OutOfMemoryError");
     out.stdoutShouldNotMatch("^" + ON_ERR_MSG);
     out.shouldHaveExitValue(0);
   }
 
   public static void failWith(String... args) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args);
-    OutputAnalyzer out = new OutputAnalyzer(pb.start());
+    OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
     out.shouldContain("OutOfMemoryError");
     if (out.getExitValue() == 0) {
       throw new IllegalStateException("Should have failed with non-zero exit code");
diff --git a/test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java b/test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java
index 288d27393a3..511f482980b 100644
--- a/test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java
+++ b/test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java
@@ -68,16 +68,16 @@ public class TestDynamicNumberOfGCThreads {
     String[] baseArgs = {"-XX:+UnlockExperimentalVMOptions", "-XX:+" + gcFlag, "-Xmx10M", "-XX:+UseDynamicNumberOfGCThreads", "-Xlog:gc+task=trace", GCTest.class.getName()};
 
     // Base test with gc and +UseDynamicNumberOfGCThreads:
-    ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder(baseArgs);
-    verifyDynamicNumberOfGCThreads(new OutputAnalyzer(pb_enabled.start()));
+    OutputAnalyzer output = ProcessTools.executeLimitedTestJava(baseArgs);
+    verifyDynamicNumberOfGCThreads(output);
 
     // Turn on parallel reference processing
     String[] parRefProcArg = {"-XX:+ParallelRefProcEnabled", "-XX:-ShowMessageBoxOnError"};
     String[] parRefArgs = new String[baseArgs.length + parRefProcArg.length];
     System.arraycopy(parRefProcArg, 0, parRefArgs, 0,                parRefProcArg.length);
     System.arraycopy(baseArgs,  0, parRefArgs, parRefProcArg.length, baseArgs.length);
-    pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder(parRefArgs);
-    verifyDynamicNumberOfGCThreads(new OutputAnalyzer(pb_enabled.start()));
+    output = ProcessTools.executeLimitedTestJava(parRefArgs);
+    verifyDynamicNumberOfGCThreads(output);
   }
 
   static class GCTest {
diff --git a/test/hotspot/jtreg/gc/ergonomics/TestInitialGCThreadLogging.java b/test/hotspot/jtreg/gc/ergonomics/TestInitialGCThreadLogging.java
index dc1b83cd2c1..e58b930b519 100644
--- a/test/hotspot/jtreg/gc/ergonomics/TestInitialGCThreadLogging.java
+++ b/test/hotspot/jtreg/gc/ergonomics/TestInitialGCThreadLogging.java
@@ -70,13 +70,13 @@ public class TestInitialGCThreadLogging {
 
   private static void testInitialGCThreadLogging(String gcFlag, String threadName) throws Exception {
     // Base test with gc and +UseDynamicNumberOfGCThreads:
-    ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder(
+    OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
         "-XX:+UnlockExperimentalVMOptions",
         "-XX:+" + gcFlag,
         "-Xmx10M",
         "-XX:+UseDynamicNumberOfGCThreads",
         "-Xlog:gc+task=trace",
         "-version");
-    verifyDynamicNumberOfGCThreads(new OutputAnalyzer(pb_enabled.start()), threadName);
+    verifyDynamicNumberOfGCThreads(output, threadName);
   }
 }
diff --git a/test/hotspot/jtreg/gc/g1/Test2GbHeap.java b/test/hotspot/jtreg/gc/g1/Test2GbHeap.java
index 8e06ac3ee2c..9b981883714 100644
--- a/test/hotspot/jtreg/gc/g1/Test2GbHeap.java
+++ b/test/hotspot/jtreg/gc/g1/Test2GbHeap.java
@@ -49,9 +49,8 @@ public class Test2GbHeap {
     testArguments.add("-Xmx2g");
     testArguments.add("-version");
 
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(testArguments);
+    OutputAnalyzer output = ProcessTools.executeLimitedTestJava(testArguments);
 
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
     output.shouldHaveExitValue(0);
   }
 }
diff --git a/test/hotspot/jtreg/gc/g1/TestAllocationFailure.java b/test/hotspot/jtreg/gc/g1/TestAllocationFailure.java
index 0723eb89f51..ab5e9d1b060 100644
--- a/test/hotspot/jtreg/gc/g1/TestAllocationFailure.java
+++ b/test/hotspot/jtreg/gc/g1/TestAllocationFailure.java
@@ -43,17 +43,16 @@ import jdk.test.lib.process.ProcessTools;
 public class TestAllocationFailure {
 
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-Xmx32M",
-                                                                             "-Xmn16M",
-                                                                             "-XX:+G1GCAllocationFailureALot",
-                                                                             "-XX:G1GCAllocationFailureALotCount=100",
-                                                                             "-XX:G1GCAllocationFailureALotInterval=1",
-                                                                             "-XX:+UnlockDiagnosticVMOptions",
-                                                                             "-Xlog:gc",
-                                                                             GCTestWithAllocationFailure.class.getName());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-Xmx32M",
+                                                                    "-Xmn16M",
+                                                                    "-XX:+G1GCAllocationFailureALot",
+                                                                    "-XX:G1GCAllocationFailureALotCount=100",
+                                                                    "-XX:G1GCAllocationFailureALotInterval=1",
+                                                                    "-XX:+UnlockDiagnosticVMOptions",
+                                                                    "-Xlog:gc",
+                                                                    GCTestWithAllocationFailure.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         System.out.println(output.getStdout());
         output.shouldContain("(Evacuation Failure:");
         output.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegions.java b/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegions.java
index a334783eca6..d1ae8ab734c 100644
--- a/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegions.java
+++ b/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegions.java
@@ -80,7 +80,7 @@ class TestEagerReclaimHumongousRegionsReclaimRegionFast {
 
 public class TestEagerReclaimHumongousRegions {
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             "-XX:+UseG1GC",
             "-Xms128M",
             "-Xmx128M",
@@ -90,8 +90,6 @@ public class TestEagerReclaimHumongousRegions {
 
         Pattern p = Pattern.compile("Full GC");
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
-
         int found = 0;
         Matcher m = p.matcher(output.getStdout());
         while (m.find()) { found++; }
diff --git a/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java b/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java
index 56de136fe59..4e4f864d339 100644
--- a/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java
+++ b/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java
@@ -119,7 +119,7 @@ class TestEagerReclaimHumongousRegionsClearMarkBitsReclaimRegionFast {
 
 public class TestEagerReclaimHumongousRegionsClearMarkBits {
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             "-XX:+UseG1GC",
             "-Xms128M",
             "-Xmx128M",
@@ -132,7 +132,6 @@ public class TestEagerReclaimHumongousRegionsClearMarkBits {
             "-XX:ConcGCThreads=1", // Want to make marking as slow as possible.
             "-XX:+G1VerifyBitmaps",
             TestEagerReclaimHumongousRegionsClearMarkBitsReclaimRegionFast.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldHaveExitValue(0);
     }
 }
diff --git a/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsLog.java b/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsLog.java
index 03af9c2b4bb..33825bff0b7 100644
--- a/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsLog.java
+++ b/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsLog.java
@@ -54,7 +54,7 @@ public class TestEagerReclaimHumongousRegionsLog {
     }
 
     public static void runTest() throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             "-Xbootclasspath/a:.",
             "-XX:+UnlockExperimentalVMOptions",
             "-XX:+UnlockDiagnosticVMOptions",
@@ -65,7 +65,6 @@ public class TestEagerReclaimHumongousRegionsLog {
             "-Xmx128M",
             "-Xlog:gc+phases=trace,gc+heap=info",
             GCTest.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
         output.shouldHaveExitValue(0);
 
diff --git a/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java b/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java
index 335567a9c36..a555977eb3e 100644
--- a/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java
+++ b/test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java
@@ -92,7 +92,7 @@ class TestEagerReclaimHumongousRegionsWithRefsReclaimRegionFast {
 public class TestEagerReclaimHumongousRegionsWithRefs {
 
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             "-XX:+UseG1GC",
             "-Xms128M",
             "-Xmx128M",
@@ -102,8 +102,6 @@ public class TestEagerReclaimHumongousRegionsWithRefs {
 
         Pattern p = Pattern.compile("Full GC");
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
-
         int found = 0;
         Matcher m = p.matcher(output.getStdout());
         while (m.find()) {
diff --git a/test/hotspot/jtreg/gc/g1/TestG1SkipCompaction.java b/test/hotspot/jtreg/gc/g1/TestG1SkipCompaction.java
index 8455e03b18f..3e986a5dede 100644
--- a/test/hotspot/jtreg/gc/g1/TestG1SkipCompaction.java
+++ b/test/hotspot/jtreg/gc/g1/TestG1SkipCompaction.java
@@ -54,8 +54,7 @@ public class TestG1SkipCompaction {
             "-XX:G1HeapRegionSize=1m",
             GCTest.class.getName()
             };
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(arguments);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(arguments);
         System.out.println(output.getStdout());
 
         String pattern = ".*skip compaction region.*";
diff --git a/test/hotspot/jtreg/gc/g1/TestG1TraceEagerReclaimHumongousObjects.java b/test/hotspot/jtreg/gc/g1/TestG1TraceEagerReclaimHumongousObjects.java
index 4dedac0a61b..d1cb29b314e 100644
--- a/test/hotspot/jtreg/gc/g1/TestG1TraceEagerReclaimHumongousObjects.java
+++ b/test/hotspot/jtreg/gc/g1/TestG1TraceEagerReclaimHumongousObjects.java
@@ -41,16 +41,14 @@ import java.util.LinkedList;
 
 public class TestG1TraceEagerReclaimHumongousObjects {
   public static void main(String[] args) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                         "-Xms128M",
-                                                                         "-Xmx128M",
-                                                                         "-Xmn16M",
-                                                                         "-XX:G1HeapRegionSize=1M",
-                                                                         "-Xlog:gc+phases=trace,gc+humongous=trace",
-                                                                         "-XX:+UnlockExperimentalVMOptions",
-                                                                         GCWithHumongousObjectTest.class.getName());
-
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                "-Xms128M",
+                                                                "-Xmx128M",
+                                                                "-Xmn16M",
+                                                                "-XX:G1HeapRegionSize=1M",
+                                                                "-Xlog:gc+phases=trace,gc+humongous=trace",
+                                                                "-XX:+UnlockExperimentalVMOptions",
+                                                                GCWithHumongousObjectTest.class.getName());
 
     System.out.println(output.getStdout());
     // As G1ReclaimDeadHumongousObjectsAtYoungGC is set(default), below logs should be displayed.
diff --git a/test/hotspot/jtreg/gc/g1/TestGCLogMessages.java b/test/hotspot/jtreg/gc/g1/TestGCLogMessages.java
index c29919e8aff..e5db6cb0dae 100644
--- a/test/hotspot/jtreg/gc/g1/TestGCLogMessages.java
+++ b/test/hotspot/jtreg/gc/g1/TestGCLogMessages.java
@@ -218,28 +218,25 @@ public class TestGCLogMessages {
 
     private void testNormalLogs() throws Exception {
 
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-Xmx10M",
-                                                                             GCTest.class.getName());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-Xmx10M",
+                                                                    GCTest.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         checkMessagesAtLevel(output, allLogMessages, Level.OFF);
         output.shouldHaveExitValue(0);
 
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                              "-Xmx10M",
-                                                              "-Xlog:gc+phases=debug",
-                                                              GCTest.class.getName());
+        output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                     "-Xmx10M",
+                                                     "-Xlog:gc+phases=debug",
+                                                     GCTest.class.getName());
 
-        output = new OutputAnalyzer(pb.start());
         checkMessagesAtLevel(output, allLogMessages, Level.DEBUG);
 
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                              "-Xmx10M",
-                                                              "-Xlog:gc+phases=trace",
-                                                              GCTest.class.getName());
+        output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                     "-Xmx10M",
+                                                     "-Xlog:gc+phases=trace",
+                                                     GCTest.class.getName());
 
-        output = new OutputAnalyzer(pb.start());
         checkMessagesAtLevel(output, allLogMessages, Level.TRACE);
         output.shouldHaveExitValue(0);
     }
@@ -253,11 +250,10 @@ public class TestGCLogMessages {
     };
 
     private void testConcurrentRefinementLogs() throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-Xmx10M",
-                                                                             "-Xlog:gc+refine+stats=debug",
-                                                                             GCTest.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-Xmx10M",
+                                                                    "-Xlog:gc+refine+stats=debug",
+                                                                    GCTest.class.getName());
         checkMessagesAtLevel(output, concRefineMessages, Level.DEBUG);
     }
 
@@ -272,29 +268,27 @@ public class TestGCLogMessages {
     };
 
     private void testWithEvacuationFailureLogs() throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-Xmx32M",
-                                                                             "-Xmn16M",
-                                                                             "-XX:+G1GCAllocationFailureALot",
-                                                                             "-XX:G1GCAllocationFailureALotCount=100",
-                                                                             "-XX:G1GCAllocationFailureALotInterval=1",
-                                                                             "-XX:+UnlockDiagnosticVMOptions",
-                                                                             "-Xlog:gc+phases=debug",
-                                                                             GCTestWithAllocationFailure.class.getName());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-Xmx32M",
+                                                                    "-Xmn16M",
+                                                                    "-XX:+G1GCAllocationFailureALot",
+                                                                    "-XX:G1GCAllocationFailureALotCount=100",
+                                                                    "-XX:G1GCAllocationFailureALotInterval=1",
+                                                                    "-XX:+UnlockDiagnosticVMOptions",
+                                                                    "-Xlog:gc+phases=debug",
+                                                                    GCTestWithAllocationFailure.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         checkMessagesAtLevel(output, exhFailureMessages, Level.DEBUG);
         output.shouldHaveExitValue(0);
 
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                              "-Xmx32M",
-                                                              "-Xmn16M",
-                                                              "-Xms32M",
-                                                              "-XX:+UnlockDiagnosticVMOptions",
-                                                              "-Xlog:gc+phases=trace",
-                                                              GCTestWithAllocationFailure.class.getName());
+        output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                     "-Xmx32M",
+                                                     "-Xmn16M",
+                                                     "-Xms32M",
+                                                     "-XX:+UnlockDiagnosticVMOptions",
+                                                     "-Xlog:gc+phases=trace",
+                                                     GCTestWithAllocationFailure.class.getName());
 
-        output = new OutputAnalyzer(pb.start());
         checkMessagesAtLevel(output, exhFailureMessages, Level.TRACE);
         output.shouldHaveExitValue(0);
     }
@@ -305,29 +299,27 @@ public class TestGCLogMessages {
     };
 
     private void testWithConcurrentStart() throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-Xmx10M",
-                                                                             "-Xbootclasspath/a:.",
-                                                                             "-Xlog:gc*=debug",
-                                                                             "-XX:+UnlockDiagnosticVMOptions",
-                                                                             "-XX:+WhiteBoxAPI",
-                                                                             GCTestWithConcurrentStart.class.getName());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-Xmx10M",
+                                                                    "-Xbootclasspath/a:.",
+                                                                    "-Xlog:gc*=debug",
+                                                                    "-XX:+UnlockDiagnosticVMOptions",
+                                                                    "-XX:+WhiteBoxAPI",
+                                                                    GCTestWithConcurrentStart.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         checkMessagesAtLevel(output, concurrentStartMessages, Level.TRACE);
         output.shouldHaveExitValue(0);
     }
 
     private void testExpandHeap() throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-Xmx10M",
-                                                                             "-Xbootclasspath/a:.",
-                                                                             "-Xlog:gc+ergo+heap=debug",
-                                                                             "-XX:+UnlockDiagnosticVMOptions",
-                                                                             "-XX:+WhiteBoxAPI",
-                                                                             GCTest.class.getName());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-Xmx10M",
+                                                                    "-Xbootclasspath/a:.",
+                                                                    "-Xlog:gc+ergo+heap=debug",
+                                                                    "-XX:+UnlockDiagnosticVMOptions",
+                                                                    "-XX:+WhiteBoxAPI",
+                                                                    GCTest.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldContain("Expand the heap. requested expansion amount: ");
         output.shouldContain("B expansion amount: ");
         output.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/g1/TestHumongousAllocConcurrentStart.java b/test/hotspot/jtreg/gc/g1/TestHumongousAllocConcurrentStart.java
index b3a754f74c5..9631fd1855c 100644
--- a/test/hotspot/jtreg/gc/g1/TestHumongousAllocConcurrentStart.java
+++ b/test/hotspot/jtreg/gc/g1/TestHumongousAllocConcurrentStart.java
@@ -45,7 +45,7 @@ public class TestHumongousAllocConcurrentStart {
     private static final int initiatingHeapOccupancyPercent = 50;  // %
 
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeTestJava(
             "-XX:+UseG1GC",
             "-Xms" + heapSize + "m",
             "-Xmx" + heapSize + "m",
@@ -54,7 +54,6 @@ public class TestHumongousAllocConcurrentStart {
             "-Xlog:gc",
             HumongousObjectAllocator.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)");
         output.shouldNotContain("Full GC");
         output.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/g1/TestHumongousAllocNearlyFullRegion.java b/test/hotspot/jtreg/gc/g1/TestHumongousAllocNearlyFullRegion.java
index fb33e9cc7c5..d6d8b5578cc 100644
--- a/test/hotspot/jtreg/gc/g1/TestHumongousAllocNearlyFullRegion.java
+++ b/test/hotspot/jtreg/gc/g1/TestHumongousAllocNearlyFullRegion.java
@@ -47,7 +47,7 @@ public class TestHumongousAllocNearlyFullRegion {
     private static final int heapRegionSize                 = 1;   // MB
 
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             "-XX:+UseG1GC",
             "-Xms" + heapSize + "m",
             "-Xmx" + heapSize + "m",
@@ -55,7 +55,6 @@ public class TestHumongousAllocNearlyFullRegion {
             "-Xlog:gc",
             HumongousObjectAllocator.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)");
         output.shouldHaveExitValue(0);
     }
diff --git a/test/hotspot/jtreg/gc/g1/TestHumongousCodeCacheRoots.java b/test/hotspot/jtreg/gc/g1/TestHumongousCodeCacheRoots.java
index 2e669f6dfe1..97ffd6c8da7 100644
--- a/test/hotspot/jtreg/gc/g1/TestHumongousCodeCacheRoots.java
+++ b/test/hotspot/jtreg/gc/g1/TestHumongousCodeCacheRoots.java
@@ -106,8 +106,7 @@ public class TestHumongousCodeCacheRoots {
     finalargs.add(classname);
     finalargs.addAll(Arrays.asList(arguments));
 
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(finalargs);
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = ProcessTools.executeLimitedTestJava(finalargs);
     output.shouldHaveExitValue(0);
     return output;
   }
diff --git a/test/hotspot/jtreg/gc/g1/TestHumongousConcurrentStartUndo.java b/test/hotspot/jtreg/gc/g1/TestHumongousConcurrentStartUndo.java
index d30d9240103..ed5ff35021a 100644
--- a/test/hotspot/jtreg/gc/g1/TestHumongousConcurrentStartUndo.java
+++ b/test/hotspot/jtreg/gc/g1/TestHumongousConcurrentStartUndo.java
@@ -56,7 +56,7 @@ public class TestHumongousConcurrentStartUndo {
     private static final int YoungSize                      = HeapSize / 8;
 
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
             "-Xbootclasspath/a:.",
             "-XX:+UseG1GC",
             "-Xms" + HeapSize + "m",
@@ -70,7 +70,6 @@ public class TestHumongousConcurrentStartUndo {
             "-Xlog:gc*",
             EdenObjectAllocatorWithHumongousAllocation.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)");
         output.shouldContain("Concurrent Undo Cycle");
         output.shouldContain("Concurrent Mark Cycle");
diff --git a/test/hotspot/jtreg/gc/g1/TestLargePageUseForAuxMemory.java b/test/hotspot/jtreg/gc/g1/TestLargePageUseForAuxMemory.java
index 777391845a4..3051cd7310b 100644
--- a/test/hotspot/jtreg/gc/g1/TestLargePageUseForAuxMemory.java
+++ b/test/hotspot/jtreg/gc/g1/TestLargePageUseForAuxMemory.java
@@ -120,12 +120,9 @@ public class TestLargePageUseForAuxMemory {
     static void testVM(String what, long heapsize, boolean cardsShouldUseLargePages, boolean bitmapShouldUseLargePages) throws Exception {
         System.out.println(what + " heapsize " + heapsize + " card table should use large pages " + cardsShouldUseLargePages + " " +
                            "bitmaps should use large pages " + bitmapShouldUseLargePages);
-        ProcessBuilder pb;
 
         // Test with large page enabled.
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder(getOpts(heapsize, true));
-
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(getOpts(heapsize, true));
 
         // Only expect large page size if large pages are enabled.
         if (largePagesEnabled(output)) {
@@ -138,9 +135,8 @@ public class TestLargePageUseForAuxMemory {
         output.shouldHaveExitValue(0);
 
         // Test with large page disabled.
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder(getOpts(heapsize, false));
+        output = ProcessTools.executeLimitedTestJava(getOpts(heapsize, false));
 
-        output = new OutputAnalyzer(pb.start());
         checkSmallTables(output, smallPageSize);
         checkBitmap(output, smallPageSize);
         output.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/g1/TestLargePageUseForHeap.java b/test/hotspot/jtreg/gc/g1/TestLargePageUseForHeap.java
index 72afde512bc..7009ae00d92 100644
--- a/test/hotspot/jtreg/gc/g1/TestLargePageUseForHeap.java
+++ b/test/hotspot/jtreg/gc/g1/TestLargePageUseForHeap.java
@@ -85,29 +85,26 @@ public class TestLargePageUseForHeap {
     }
 
     static void testVM(long regionSize) throws Exception {
-        ProcessBuilder pb;
         // Test with large page enabled.
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                              "-XX:G1HeapRegionSize=" + regionSize,
-                                                              "-Xmx128m",
-                                                              "-Xlog:gc+init,pagesize,gc+heap+coops=debug",
-                                                              "-XX:+UseLargePages",
-                                                              "-version");
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-XX:G1HeapRegionSize=" + regionSize,
+                                                                    "-Xmx128m",
+                                                                    "-Xlog:gc+init,pagesize,gc+heap+coops=debug",
+                                                                    "-XX:+UseLargePages",
+                                                                    "-version");
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         boolean largePageEnabled = checkLargePageEnabled(output);
         checkHeap(output, largePageEnabled ? largePageSize : smallPageSize);
         output.shouldHaveExitValue(0);
 
         // Test with large page disabled.
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                              "-XX:G1HeapRegionSize=" + regionSize,
-                                                              "-Xmx128m",
-                                                              "-Xlog:gc+init,pagesize,gc+heap+coops=debug",
-                                                              "-XX:-UseLargePages",
-                                                              "-version");
+        output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                     "-XX:G1HeapRegionSize=" + regionSize,
+                                                     "-Xmx128m",
+                                                     "-Xlog:gc+init,pagesize,gc+heap+coops=debug",
+                                                     "-XX:-UseLargePages",
+                                                     "-version");
 
-        output = new OutputAnalyzer(pb.start());
         checkHeap(output, smallPageSize);
         output.shouldHaveExitValue(0);
     }
diff --git a/test/hotspot/jtreg/gc/g1/TestMarkStackSizes.java b/test/hotspot/jtreg/gc/g1/TestMarkStackSizes.java
index d056a5ef747..0a1c373199c 100644
--- a/test/hotspot/jtreg/gc/g1/TestMarkStackSizes.java
+++ b/test/hotspot/jtreg/gc/g1/TestMarkStackSizes.java
@@ -50,9 +50,7 @@ public class TestMarkStackSizes {
         Collections.addAll(testArguments, extraArgs);
         testArguments.add("-version");
 
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(testArguments);
-
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(testArguments);
 
         System.out.println(output.getStderr());
 
diff --git a/test/hotspot/jtreg/gc/g1/TestMixedGCLiveThreshold.java b/test/hotspot/jtreg/gc/g1/TestMixedGCLiveThreshold.java
index 035a6b89679..e0aa0827749 100644
--- a/test/hotspot/jtreg/gc/g1/TestMixedGCLiveThreshold.java
+++ b/test/hotspot/jtreg/gc/g1/TestMixedGCLiveThreshold.java
@@ -109,9 +109,7 @@ public class TestMixedGCLiveThreshold {
 
         basicOpts.add(GCTest.class.getName());
 
-        ProcessBuilder procBuilder =  ProcessTools.createLimitedTestJavaProcessBuilder(basicOpts);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
-        return analyzer;
+        return ProcessTools.executeLimitedTestJava(basicOpts);
     }
 
     private static boolean regionsSelectedForRebuild(String output) throws Exception {
diff --git a/test/hotspot/jtreg/gc/g1/TestOneEdenRegionAfterGC.java b/test/hotspot/jtreg/gc/g1/TestOneEdenRegionAfterGC.java
index 36c3c04c629..6bbf0213f36 100644
--- a/test/hotspot/jtreg/gc/g1/TestOneEdenRegionAfterGC.java
+++ b/test/hotspot/jtreg/gc/g1/TestOneEdenRegionAfterGC.java
@@ -40,7 +40,7 @@ public class TestOneEdenRegionAfterGC {
   private static long YoungGenSize = 32 * 1024 * 1024;
 
   private static OutputAnalyzer run() throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+    return ProcessTools.executeLimitedTestJava(
       "-Xbootclasspath/a:.",
       "-Xmn" + YoungGenSize,
       "-Xmx512M",
@@ -50,7 +50,6 @@ public class TestOneEdenRegionAfterGC {
       "-Xlog:gc,gc+ergo*=trace",
       TestOneEdenRegionAfterGC.Allocate.class.getName(),
       "" + YoungGenSize);
-    return new OutputAnalyzer(pb.start());
   }
 
   public static void main(String args[]) throws Exception {
diff --git a/test/hotspot/jtreg/gc/g1/TestPLABOutput.java b/test/hotspot/jtreg/gc/g1/TestPLABOutput.java
index e6342a1911c..fecb8dcfc41 100644
--- a/test/hotspot/jtreg/gc/g1/TestPLABOutput.java
+++ b/test/hotspot/jtreg/gc/g1/TestPLABOutput.java
@@ -59,8 +59,7 @@ public class TestPLABOutput {
             GCTest.class.getName()
             };
 
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(arguments);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(arguments);
 
         output.shouldHaveExitValue(0);
 
diff --git a/test/hotspot/jtreg/gc/g1/TestPLABSizeBounds.java b/test/hotspot/jtreg/gc/g1/TestPLABSizeBounds.java
index ade281a4a92..c0427e1ada3 100644
--- a/test/hotspot/jtreg/gc/g1/TestPLABSizeBounds.java
+++ b/test/hotspot/jtreg/gc/g1/TestPLABSizeBounds.java
@@ -62,8 +62,7 @@ public class TestPLABSizeBounds {
         testArguments.add("-XX:OldPLABSize=" + plabSize);
         testArguments.add(GCTest.class.getName());
 
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(testArguments);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(testArguments);
 
         if (shouldSucceed) {
             output.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/g1/TestPeriodicLogMessages.java b/test/hotspot/jtreg/gc/g1/TestPeriodicLogMessages.java
index de79be020b4..7b4303e55a2 100644
--- a/test/hotspot/jtreg/gc/g1/TestPeriodicLogMessages.java
+++ b/test/hotspot/jtreg/gc/g1/TestPeriodicLogMessages.java
@@ -40,24 +40,22 @@ import jdk.test.lib.process.ProcessTools;
 public class TestPeriodicLogMessages {
 
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-XX:G1PeriodicGCInterval=0",
-                                                                             "-Xlog:gc+init,gc+periodic=debug",
-                                                                             "-Xmx10M",
-                                                                             GCTest.class.getName());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-XX:G1PeriodicGCInterval=0",
+                                                                    "-Xlog:gc+init,gc+periodic=debug",
+                                                                    "-Xmx10M",
+                                                                    GCTest.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldContain("Periodic GC: Disabled");
         output.shouldNotContain("Checking for periodic GC");
         output.shouldHaveExitValue(0);
 
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                              "-XX:G1PeriodicGCInterval=100",
-                                                              "-Xlog:gc+init,gc+periodic=debug",
-                                                              "-Xmx10M",
-                                                              GCTest.class.getName());
+        output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                     "-XX:G1PeriodicGCInterval=100",
+                                                     "-Xlog:gc+init,gc+periodic=debug",
+                                                     "-Xmx10M",
+                                                     GCTest.class.getName());
 
-        output = new OutputAnalyzer(pb.start());
         output.shouldContain("Periodic GC: Enabled");
         output.shouldContain("Periodic GC Interval: 100ms");
         output.shouldContain("Checking for periodic GC");
diff --git a/test/hotspot/jtreg/gc/g1/TestPrintRegionRememberedSetInfo.java b/test/hotspot/jtreg/gc/g1/TestPrintRegionRememberedSetInfo.java
index ea718c7f6ed..11f02643d1d 100644
--- a/test/hotspot/jtreg/gc/g1/TestPrintRegionRememberedSetInfo.java
+++ b/test/hotspot/jtreg/gc/g1/TestPrintRegionRememberedSetInfo.java
@@ -69,8 +69,7 @@ public class TestPrintRegionRememberedSetInfo {
 
         finalargs.add(RunAndWaitForMarking.class.getName());
 
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(finalargs);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(finalargs);
         output.shouldHaveExitValue(0);
 
         String result = output.getStdout();
diff --git a/test/hotspot/jtreg/gc/g1/TestRemsetLoggingThreads.java b/test/hotspot/jtreg/gc/g1/TestRemsetLoggingThreads.java
index 5d4b4d958f8..c2b1be60322 100644
--- a/test/hotspot/jtreg/gc/g1/TestRemsetLoggingThreads.java
+++ b/test/hotspot/jtreg/gc/g1/TestRemsetLoggingThreads.java
@@ -44,14 +44,12 @@ import jdk.test.lib.process.ProcessTools;
 public class TestRemsetLoggingThreads {
 
   private static void runTest(int refinementThreads, int workerThreads) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                         "-XX:+UnlockDiagnosticVMOptions",
-                                                                         "-Xlog:gc+remset+exit=trace",
-                                                                         "-XX:G1ConcRefinementThreads=" + refinementThreads,
-                                                                         "-XX:ParallelGCThreads=" + workerThreads,
-                                                                         "-version");
-
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                "-XX:+UnlockDiagnosticVMOptions",
+                                                                "-Xlog:gc+remset+exit=trace",
+                                                                "-XX:G1ConcRefinementThreads=" + refinementThreads,
+                                                                "-XX:ParallelGCThreads=" + workerThreads,
+                                                                "-version");
 
     String pattern = "Concurrent refinement threads times \\(s\\)$";
     Matcher m = Pattern.compile(pattern, Pattern.MULTILINE).matcher(output.getStdout());
diff --git a/test/hotspot/jtreg/gc/g1/TestRemsetLoggingTools.java b/test/hotspot/jtreg/gc/g1/TestRemsetLoggingTools.java
index 69f34e07146..7e44c41e1a4 100644
--- a/test/hotspot/jtreg/gc/g1/TestRemsetLoggingTools.java
+++ b/test/hotspot/jtreg/gc/g1/TestRemsetLoggingTools.java
@@ -77,8 +77,7 @@ public class TestRemsetLoggingTools {
         finalargs.add(VerifySummaryOutput.class.getName());
         finalargs.add(String.valueOf(numGCs));
 
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(finalargs);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(finalargs);
 
         output.shouldHaveExitValue(0);
 
diff --git a/test/hotspot/jtreg/gc/g1/TestSharedArchiveWithPreTouch.java b/test/hotspot/jtreg/gc/g1/TestSharedArchiveWithPreTouch.java
index d894c58d737..aef9a98530c 100644
--- a/test/hotspot/jtreg/gc/g1/TestSharedArchiveWithPreTouch.java
+++ b/test/hotspot/jtreg/gc/g1/TestSharedArchiveWithPreTouch.java
@@ -50,8 +50,6 @@ public class TestSharedArchiveWithPreTouch {
         final List<String> BaseOptions = Arrays.asList(new String[] {"-XX:+UseG1GC", "-XX:+AlwaysPreTouch",
             "-XX:+UnlockDiagnosticVMOptions", "-XX:SharedArchiveFile=" + ArchiveFileName });
 
-        ProcessBuilder pb;
-
         List<String> dump_args = new ArrayList<String>(BaseOptions);
 
         if (Platform.is64bit()) {
@@ -59,8 +57,8 @@ public class TestSharedArchiveWithPreTouch {
         }
         dump_args.addAll(Arrays.asList(new String[] { "-Xshare:dump", "-Xlog:cds" }));
 
-        pb = ProcessTools.createLimitedTestJavaProcessBuilder(dump_args);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(dump_args);
+
         try {
             output.shouldContain("Loading classes to share");
             output.shouldHaveExitValue(0);
@@ -72,8 +70,7 @@ public class TestSharedArchiveWithPreTouch {
             }
             load_args.addAll(Arrays.asList(new String[] { "-Xshare:on", "-version" }));
 
-            pb = ProcessTools.createLimitedTestJavaProcessBuilder(load_args.toArray(new String[0]));
-            output = new OutputAnalyzer(pb.start());
+            output = ProcessTools.executeLimitedTestJava(load_args.toArray(new String[0]));
             output.shouldContain("sharing");
             output.shouldHaveExitValue(0);
         } catch (RuntimeException e) {
diff --git a/test/hotspot/jtreg/gc/g1/TestShrinkAuxiliaryData.java b/test/hotspot/jtreg/gc/g1/TestShrinkAuxiliaryData.java
index 645e545443d..8f68ccba9ad 100644
--- a/test/hotspot/jtreg/gc/g1/TestShrinkAuxiliaryData.java
+++ b/test/hotspot/jtreg/gc/g1/TestShrinkAuxiliaryData.java
@@ -88,9 +88,8 @@ public class TestShrinkAuxiliaryData {
     }
 
     private void performTest(List<String> opts) throws Exception {
-        ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(opts);
+        OutputAnalyzer output = ProcessTools.executeTestJava(opts);
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         System.out.println(output.getStdout());
         System.err.println(output.getStderr());
         output.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/g1/TestShrinkDefragmentedHeap.java b/test/hotspot/jtreg/gc/g1/TestShrinkDefragmentedHeap.java
index acdce6b6417..7934660a323 100644
--- a/test/hotspot/jtreg/gc/g1/TestShrinkDefragmentedHeap.java
+++ b/test/hotspot/jtreg/gc/g1/TestShrinkDefragmentedHeap.java
@@ -61,7 +61,7 @@ public class TestShrinkDefragmentedHeap {
     private static final int REGION_SIZE        = 1 * 1024 * 1024;
 
     public static void main(String[] args) throws Exception, Throwable {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                 "-XX:InitialHeapSize=" + INITIAL_HEAP_SIZE,
                 "-Xmn" + MINIMAL_YOUNG_SIZE,
                 "-Xmx" + MAXIMUM_HEAP_SIZE,
@@ -74,7 +74,6 @@ public class TestShrinkDefragmentedHeap {
                 GCTest.class.getName()
         );
 
-        OutputAnalyzer output = ProcessTools.executeProcess(pb);
         output.shouldHaveExitValue(0);
     }
 
diff --git a/test/hotspot/jtreg/gc/g1/TestSkipRebuildRemsetPhase.java b/test/hotspot/jtreg/gc/g1/TestSkipRebuildRemsetPhase.java
index 4c7190ada02..f7f768c9d7d 100644
--- a/test/hotspot/jtreg/gc/g1/TestSkipRebuildRemsetPhase.java
+++ b/test/hotspot/jtreg/gc/g1/TestSkipRebuildRemsetPhase.java
@@ -40,17 +40,16 @@ import jdk.test.whitebox.WhiteBox;
 
 public class TestSkipRebuildRemsetPhase {
     public static void main(String[] args) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-Xbootclasspath/a:.",
-                                                                             "-XX:+UseG1GC",
-                                                                             "-XX:+UnlockExperimentalVMOptions",
-                                                                             "-XX:+UnlockDiagnosticVMOptions",
-                                                                             "-XX:+WhiteBoxAPI",
-                                                                             "-XX:G1MixedGCLiveThresholdPercent=20",
-                                                                             "-Xlog:gc+marking=debug,gc+phases=debug,gc+remset+tracking=trace",
-                                                                             "-Xms10M",
-                                                                             "-Xmx10M",
-                                                                             GCTest.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xbootclasspath/a:.",
+                                                                    "-XX:+UseG1GC",
+                                                                    "-XX:+UnlockExperimentalVMOptions",
+                                                                    "-XX:+UnlockDiagnosticVMOptions",
+                                                                    "-XX:+WhiteBoxAPI",
+                                                                    "-XX:G1MixedGCLiveThresholdPercent=20",
+                                                                    "-Xlog:gc+marking=debug,gc+phases=debug,gc+remset+tracking=trace",
+                                                                    "-Xms10M",
+                                                                    "-Xmx10M",
+                                                                    GCTest.class.getName());
         output.shouldContain("Skipping Remembered Set Rebuild.");
         output.shouldContain("No Remembered Sets to update after rebuild");
         output.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/g1/TestVerifyGCType.java b/test/hotspot/jtreg/gc/g1/TestVerifyGCType.java
index d14fcf95de1..2f3b3128038 100644
--- a/test/hotspot/jtreg/gc/g1/TestVerifyGCType.java
+++ b/test/hotspot/jtreg/gc/g1/TestVerifyGCType.java
@@ -178,10 +178,7 @@ public class TestVerifyGCType {
 
         basicOpts.add(TriggerGCs.class.getName());
 
-        ProcessBuilder procBuilder =  ProcessTools.createLimitedTestJavaProcessBuilder(basicOpts);
-        OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
-
-        return analyzer;
+        return ProcessTools.executeLimitedTestJava(basicOpts);
     }
 
     private static void verifyCollection(String name, boolean expectBefore, boolean expectDuring, boolean expectAfter, String data) {
diff --git a/test/hotspot/jtreg/gc/g1/humongousObjects/ClassLoaderGenerator.java b/test/hotspot/jtreg/gc/g1/humongousObjects/ClassLoaderGenerator.java
index 25510063b55..01ad5e1c0b3 100644
--- a/test/hotspot/jtreg/gc/g1/humongousObjects/ClassLoaderGenerator.java
+++ b/test/hotspot/jtreg/gc/g1/humongousObjects/ClassLoaderGenerator.java
@@ -34,7 +34,7 @@ import java.nio.file.Paths;
  * Since the generation depends on current host architecture it cannot be done as part of pre-compilation step
  */
 public class ClassLoaderGenerator {
-    public static void main(String[] args) throws IOException {
+    public static void main(String[] args) throws Exception {
 
         if (args.length != 1) {
             throw new Error("Test Bug: Expected region size wasn't provided as command line argument");
@@ -47,7 +47,7 @@ public class ClassLoaderGenerator {
 
     }
 
-    public static void generateClassLoader(long regionSize, Path wrkDir) throws IOException {
+    public static void generateClassLoader(long regionSize, Path wrkDir) throws Exception {
         // Generating simple classloader
         String finalSimpleClassLoaderPrototype = TestHumongousClassLoader.GENERIC_PROTOTYPE
                 .replace("${Methods}",
diff --git a/test/hotspot/jtreg/gc/g1/humongousObjects/G1SampleClass.java b/test/hotspot/jtreg/gc/g1/humongousObjects/G1SampleClass.java
index 1a321c9b115..8e11eff2749 100644
--- a/test/hotspot/jtreg/gc/g1/humongousObjects/G1SampleClass.java
+++ b/test/hotspot/jtreg/gc/g1/humongousObjects/G1SampleClass.java
@@ -75,12 +75,11 @@ public enum G1SampleClass {
      * @param wrkDir working dir where generated classes are put and compiled
      * @param classNamePrefix prefix for service classes (ones we use to create chain of inheritance)
      * @return a class with instances of the specified size loaded in specified class loader
-     * @throws IOException
-     * @throws ClassNotFoundException
+     * @throws Exception
      */
 
     public Class<?> getCls(ClassLoader classLoader, Path wrkDir, String classNamePrefix)
-            throws IOException, ClassNotFoundException {
+            throws Exception {
         return Helpers.generateCompileAndLoad(classLoader, Helpers.enumNameToClassName(name()) + "Class",
                 expectedInstanceSize(), wrkDir, classNamePrefix);
     }
diff --git a/test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousClassLoader.java b/test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousClassLoader.java
index c2be830f57c..34333e90ef2 100644
--- a/test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousClassLoader.java
+++ b/test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousClassLoader.java
@@ -140,9 +140,7 @@ public class TestHumongousClassLoader {
         public abstract void provoke();
     }
 
-    public static void main(String[] args) throws ClassNotFoundException, InstantiationException,
-            IllegalAccessException, IOException, NoSuchMethodException, InvocationTargetException {
-
+    public static void main(String[] args) throws Exception {
         if (args.length != 1) {
             throw new Error("Test Bug: Expected GC type wasn't provided as command line argument");
         }
diff --git a/test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousNonArrayAllocation.java b/test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousNonArrayAllocation.java
index 32a4251a6a8..0e432177208 100644
--- a/test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousNonArrayAllocation.java
+++ b/test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousNonArrayAllocation.java
@@ -82,8 +82,7 @@ public class TestHumongousNonArrayAllocation {
     private static final WhiteBox WB = WhiteBox.getWhiteBox();
     private static final String CLASS_NAME_PREFIX = TestHumongousNonArrayAllocation.class.getSimpleName() + "_";
 
-    public static void main(String[] args) throws ClassNotFoundException, InstantiationException,
-            IllegalAccessException, IOException {
+    public static void main(String[] args) throws Exception {
 
         if (args.length != 1) {
             throw new Error("Test Bug: Expected class name wasn't provided as command line argument");
diff --git a/test/hotspot/jtreg/gc/g1/mixedgc/TestLogging.java b/test/hotspot/jtreg/gc/g1/mixedgc/TestLogging.java
index 0c8d4896c4e..0e8f2b47762 100644
--- a/test/hotspot/jtreg/gc/g1/mixedgc/TestLogging.java
+++ b/test/hotspot/jtreg/gc/g1/mixedgc/TestLogging.java
@@ -90,8 +90,7 @@ public class TestLogging {
         Collections.addAll(testOpts, extraFlags);
         testOpts.add(RunMixedGC.class.getName());
         System.out.println(testOpts);
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(testOpts);
-        return new OutputAnalyzer(pb.start());
+        return ProcessTools.executeLimitedTestJava(testOpts);
     }
 }
 
diff --git a/test/hotspot/jtreg/gc/g1/numa/TestG1NUMATouchRegions.java b/test/hotspot/jtreg/gc/g1/numa/TestG1NUMATouchRegions.java
index 4f972e10f31..832281c8257 100644
--- a/test/hotspot/jtreg/gc/g1/numa/TestG1NUMATouchRegions.java
+++ b/test/hotspot/jtreg/gc/g1/numa/TestG1NUMATouchRegions.java
@@ -181,7 +181,7 @@ public class TestG1NUMATouchRegions {
             return;
         }
 
-        ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                                               "-Xbootclasspath/a:.",
                                               "-Xlog:pagesize,gc+heap+region=trace",
                                               "-XX:+UseG1GC",
@@ -195,7 +195,6 @@ public class TestG1NUMATouchRegions {
                                               largePagesSetting,
                                               "-XX:G1HeapRegionSize=" + regionSizeInMB + "m",
                                               GCTest.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb_enabled.start());
 
         // Check NUMA availability.
         if (status == NUMASupportStatus.NOT_CHECKED) {
diff --git a/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectTypes.java b/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectTypes.java
index 1223bfdd027..c96f1a1759a 100644
--- a/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectTypes.java
+++ b/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectTypes.java
@@ -48,18 +48,17 @@ public class TestPinnedObjectTypes {
     }
 
     private static void testPinning(String type, boolean shouldSucceed) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-XX:+UnlockDiagnosticVMOptions",
-                                                                             "-XX:+WhiteBoxAPI",
-                                                                             "-Xbootclasspath/a:.",
-                                                                             "-XX:-CreateCoredumpOnCrash",
-                                                                             "-Xmx32M",
-                                                                             "-Xmn16M",
-                                                                             "-Xlog:gc",
-                                                                             TestObjectPin.class.getName(),
-                                                                             type);
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-XX:+UnlockDiagnosticVMOptions",
+                                                                    "-XX:+WhiteBoxAPI",
+                                                                    "-Xbootclasspath/a:.",
+                                                                    "-XX:-CreateCoredumpOnCrash",
+                                                                    "-Xmx32M",
+                                                                    "-Xmn16M",
+                                                                    "-Xlog:gc",
+                                                                    TestObjectPin.class.getName(),
+                                                                    type);
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         System.out.println(output.getStdout());
         if (shouldSucceed) {
           output.shouldHaveExitValue(0);
@@ -84,4 +83,3 @@ class TestObjectPin {
         wb.pinObject(o);
     }
 }
-
diff --git a/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectsEvacuation.java b/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectsEvacuation.java
index 7ffd9432eb5..975b1feb536 100644
--- a/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectsEvacuation.java
+++ b/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectsEvacuation.java
@@ -64,19 +64,18 @@ public class TestPinnedObjectsEvacuation {
     }
 
     private static void testPinnedEvacuation(int younGCsBeforeUnpin, int expectedSkipEvents, int expectedDropEvents, int expectedReclaimEvents) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-XX:+UnlockDiagnosticVMOptions",
-                                                                             "-XX:+WhiteBoxAPI",
-                                                                             "-Xbootclasspath/a:.",
-                                                                             "-Xmx32M",
-                                                                             "-Xmn16M",
-                                                                             "-XX:G1NumCollectionsKeepPinned=2",
-                                                                             "-XX:+VerifyAfterGC",
-                                                                             "-Xlog:gc,gc+ergo+cset=trace",
-                                                                             TestObjectPin.class.getName(),
-                                                                             String.valueOf(younGCsBeforeUnpin));
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-XX:+UnlockDiagnosticVMOptions",
+                                                                    "-XX:+WhiteBoxAPI",
+                                                                    "-Xbootclasspath/a:.",
+                                                                    "-Xmx32M",
+                                                                    "-Xmn16M",
+                                                                    "-XX:G1NumCollectionsKeepPinned=2",
+                                                                    "-XX:+VerifyAfterGC",
+                                                                    "-Xlog:gc,gc+ergo+cset=trace",
+                                                                    TestObjectPin.class.getName(),
+                                                                    String.valueOf(younGCsBeforeUnpin));
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         System.out.println(output.getStdout());
         output.shouldHaveExitValue(0);
 
@@ -128,4 +127,3 @@ class TestObjectPin {
         wb.youngGC();
     }
 }
-
diff --git a/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedOldObjectsEvacuation.java b/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedOldObjectsEvacuation.java
index 86f7a62ef70..f30b3e8a7a5 100644
--- a/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedOldObjectsEvacuation.java
+++ b/test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedOldObjectsEvacuation.java
@@ -257,24 +257,23 @@ public class TestPinnedOldObjectsEvacuation {
                                              int expectedDropEvents,
                                              int expectedMarkingReclaimEvents,
                                              int expectedRetainedReclaimEvents) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC",
-                                                                             "-XX:+UnlockDiagnosticVMOptions",
-                                                                             "-XX:+WhiteBoxAPI",
-                                                                             "-Xbootclasspath/a:.",
-                                                                             "-Xmx32M",
-                                                                             "-Xmn16M",
-                                                                             "-XX:MarkSweepDeadRatio=0",
-                                                                             "-XX:G1NumCollectionsKeepPinned=3",
-                                                                             "-XX:+UnlockExperimentalVMOptions",
-                                                                             // Take all old regions to make sure that the pinned one is included in the collection set.
-                                                                             "-XX:G1MixedGCLiveThresholdPercent=100",
-                                                                             "-XX:G1HeapWastePercent=0",
-                                                                             "-XX:+VerifyAfterGC",
-                                                                             "-Xlog:gc,gc+ergo+cset=trace",
-                                                                             TestObjectPin.class.getName(),
-                                                                             String.valueOf(youngGCsBeforeUnpin));
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
+                                                                    "-XX:+UnlockDiagnosticVMOptions",
+                                                                    "-XX:+WhiteBoxAPI",
+                                                                    "-Xbootclasspath/a:.",
+                                                                    "-Xmx32M",
+                                                                    "-Xmn16M",
+                                                                    "-XX:MarkSweepDeadRatio=0",
+                                                                    "-XX:G1NumCollectionsKeepPinned=3",
+                                                                    "-XX:+UnlockExperimentalVMOptions",
+                                                                    // Take all old regions to make sure that the pinned one is included in the collection set.
+                                                                    "-XX:G1MixedGCLiveThresholdPercent=100",
+                                                                    "-XX:G1HeapWastePercent=0",
+                                                                    "-XX:+VerifyAfterGC",
+                                                                    "-Xlog:gc,gc+ergo+cset=trace",
+                                                                    TestObjectPin.class.getName(),
+                                                                    String.valueOf(youngGCsBeforeUnpin));
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         System.out.println(output.getStdout());
         output.shouldHaveExitValue(0);
 
@@ -334,4 +333,3 @@ class TestObjectPin {
         wb.youngGC();
     }
 }
-
diff --git a/test/hotspot/jtreg/gc/logging/TestDeprecatedPrintFlags.java b/test/hotspot/jtreg/gc/logging/TestDeprecatedPrintFlags.java
index 04607502a22..78089ea6452 100644
--- a/test/hotspot/jtreg/gc/logging/TestDeprecatedPrintFlags.java
+++ b/test/hotspot/jtreg/gc/logging/TestDeprecatedPrintFlags.java
@@ -42,8 +42,7 @@ import java.util.stream.Collectors;
 public class TestDeprecatedPrintFlags {
 
     public static void testPrintGC() throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+PrintGC", DoGC.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+PrintGC", DoGC.class.getName());
         output.shouldContain("-XX:+PrintGC is deprecated. Will use -Xlog:gc instead.");
         output.shouldNotContain("PrintGCDetails");
         output.stdoutShouldMatch("\\[info.*\\]\\[gc *\\]");
@@ -52,8 +51,7 @@ public class TestDeprecatedPrintFlags {
     }
 
     public static void testPrintGCDetails() throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+PrintGCDetails", DoGC.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+PrintGCDetails", DoGC.class.getName());
         output.shouldContain("-XX:+PrintGCDetails is deprecated. Will use -Xlog:gc* instead.");
         output.shouldNotContain("PrintGC is deprecated");
         output.stdoutShouldMatch("\\[info.*\\]\\[gc *\\]");
@@ -63,8 +61,7 @@ public class TestDeprecatedPrintFlags {
 
     public static void testXloggc() throws Exception {
         String fileName = "gc-test.log";
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-Xloggc:" + fileName, DoGC.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xloggc:" + fileName, DoGC.class.getName());
         output.shouldContain("-Xloggc is deprecated. Will use -Xlog:gc:gc-test.log instead.");
         output.shouldNotContain("PrintGCDetails");
         output.shouldNotContain("PrintGC");
@@ -80,8 +77,7 @@ public class TestDeprecatedPrintFlags {
 
     public static void testXloggcWithPrintGCDetails() throws Exception {
         String fileName = "gc-test.log";
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+PrintGCDetails", "-Xloggc:" + fileName, DoGC.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+PrintGCDetails", "-Xloggc:" + fileName, DoGC.class.getName());
         output.shouldContain("-XX:+PrintGCDetails is deprecated. Will use -Xlog:gc* instead.");
         output.shouldContain("-Xloggc is deprecated. Will use -Xlog:gc:gc-test.log instead.");
         output.shouldNotContain("PrintGC is deprecated");
diff --git a/test/hotspot/jtreg/gc/logging/TestGCId.java b/test/hotspot/jtreg/gc/logging/TestGCId.java
index dca1681e0e8..b1015f46435 100644
--- a/test/hotspot/jtreg/gc/logging/TestGCId.java
+++ b/test/hotspot/jtreg/gc/logging/TestGCId.java
@@ -73,9 +73,9 @@ public class TestGCId {
   }
 
   private static void testGCId(String gcFlag) throws Exception {
-    ProcessBuilder pb_default =
-      ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions", "-XX:+" + gcFlag, "-Xlog:gc", "-Xmx10M", GCTest.class.getName());
-    verifyContainsGCIDs(new OutputAnalyzer(pb_default.start()));
+    OutputAnalyzer output =
+      ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions", "-XX:+" + gcFlag, "-Xlog:gc", "-Xmx10M", GCTest.class.getName());
+    verifyContainsGCIDs(output);
   }
 
   static class GCTest {
diff --git a/test/hotspot/jtreg/gc/logging/TestMetaSpaceLog.java b/test/hotspot/jtreg/gc/logging/TestMetaSpaceLog.java
index b67063091fb..044ad1cf9f5 100644
--- a/test/hotspot/jtreg/gc/logging/TestMetaSpaceLog.java
+++ b/test/hotspot/jtreg/gc/logging/TestMetaSpaceLog.java
@@ -93,24 +93,24 @@ public class TestMetaSpaceLog {
   }
 
   private static void testMetaSpaceUpdate() throws Exception {
-    ProcessBuilder pb =
-      ProcessTools.createTestJavaProcessBuilder(
-          "-Xlog:gc*",
-          "-Xbootclasspath/a:.",
-          "-XX:+UnlockDiagnosticVMOptions",
-          "-XX:+WhiteBoxAPI",
-          "-Xmx1000M",
-          "-Xms1000M",
-          StressMetaSpace.class.getName());
-
     OutputAnalyzer output = null;
     try {
-      output = new OutputAnalyzer(pb.start());
+      output = ProcessTools.executeTestJava(
+            "-Xlog:gc*",
+            "-Xbootclasspath/a:.",
+            "-XX:+UnlockDiagnosticVMOptions",
+            "-XX:+WhiteBoxAPI",
+            "-Xmx1000M",
+            "-Xms1000M",
+            StressMetaSpace.class.getName());
+
       verifyContainsMetaSpaceUpdate(output);
     } catch (Exception e) {
       // For error diagnosis: print and throw.
       e.printStackTrace();
-      output.reportDiagnosticSummary();
+      if (output != null) {
+        output.reportDiagnosticSummary();
+      }
       throw e;
     }
   }
diff --git a/test/hotspot/jtreg/gc/logging/TestPrintReferences.java b/test/hotspot/jtreg/gc/logging/TestPrintReferences.java
index 99932bc68a6..96e0e7f14d4 100644
--- a/test/hotspot/jtreg/gc/logging/TestPrintReferences.java
+++ b/test/hotspot/jtreg/gc/logging/TestPrintReferences.java
@@ -67,11 +67,10 @@ public class TestPrintReferences {
     }
 
     public static void testRefs() throws Exception {
-        ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder("-Xlog:gc+ref+phases=debug",
-                                                                                     "-XX:+UseG1GC",
-                                                                                     "-Xmx32M",
-                                                                                     GCTest.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb_enabled.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xlog:gc+ref+phases=debug",
+                                                                    "-XX:+UseG1GC",
+                                                                    "-Xmx32M",
+                                                                    GCTest.class.getName());
 
         checkRefsLogFormat(output);
 
@@ -95,14 +94,13 @@ public class TestPrintReferences {
     }
 
     public static void testPhases(boolean parallelRefProcEnabled) throws Exception {
-        ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder("-Xlog:gc+phases+ref=debug",
-                                                                                     "-XX:+UseG1GC",
-                                                                                     "-Xmx32M",
-                                                                                     "-XX:" + (parallelRefProcEnabled ? "+" : "-") + "ParallelRefProcEnabled",
-                                                                                     "-XX:-UseDynamicNumberOfGCThreads",
-                                                                                     "-XX:ParallelGCThreads=2",
-                                                                                     GCTest.class.getName());
-        OutputAnalyzer output = new OutputAnalyzer(pb_enabled.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xlog:gc+phases+ref=debug",
+                                                                    "-XX:+UseG1GC",
+                                                                    "-Xmx32M",
+                                                                    "-XX:" + (parallelRefProcEnabled ? "+" : "-") + "ParallelRefProcEnabled",
+                                                                    "-XX:-UseDynamicNumberOfGCThreads",
+                                                                    "-XX:ParallelGCThreads=2",
+                                                                    GCTest.class.getName());
 
         checkLogFormat(output, parallelRefProcEnabled);
         checkLogValue(output);
diff --git a/test/hotspot/jtreg/gc/metaspace/CompressedClassSpaceSizeInJmapHeap.java b/test/hotspot/jtreg/gc/metaspace/CompressedClassSpaceSizeInJmapHeap.java
index 30553a7b8c6..5955006ec0f 100644
--- a/test/hotspot/jtreg/gc/metaspace/CompressedClassSpaceSizeInJmapHeap.java
+++ b/test/hotspot/jtreg/gc/metaspace/CompressedClassSpaceSizeInJmapHeap.java
@@ -77,9 +77,8 @@ public class CompressedClassSpaceSizeInJmapHeap {
     }
 
     private static void run(ProcessBuilder pb) throws Exception {
-        Process p = pb.start();
-        p.waitFor();
-        int exitValue = p.exitValue();
+        OutputAnalyzer output = ProcessTools.executeProcess(pb);
+        int exitValue = output.getExitValue();
         if (exitValue != 0) {
             throw new Exception("jmap -heap exited with error code: " + exitValue);
         }
diff --git a/test/hotspot/jtreg/gc/metaspace/TestMetaspaceSizeFlags.java b/test/hotspot/jtreg/gc/metaspace/TestMetaspaceSizeFlags.java
index eda71fa9c4b..7e6066557dd 100644
--- a/test/hotspot/jtreg/gc/metaspace/TestMetaspaceSizeFlags.java
+++ b/test/hotspot/jtreg/gc/metaspace/TestMetaspaceSizeFlags.java
@@ -84,13 +84,12 @@ public class TestMetaspaceSizeFlags {
   }
 
   private static OutputAnalyzer run(long maxMetaspaceSize, long metaspaceSize) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+    return ProcessTools.executeLimitedTestJava(
         "-XX:MaxMetaspaceSize=" + maxMetaspaceSize,
         "-XX:MetaspaceSize=" + metaspaceSize,
         "-XX:-UseLargePages", // Prevent us from using 2GB large pages on solaris + sparc.
         "-XX:+PrintFlagsFinal",
         "-version");
-    return new OutputAnalyzer(pb.start());
   }
 
   private static class MetaspaceFlags {
diff --git a/test/hotspot/jtreg/gc/metaspace/TestSizeTransitions.java b/test/hotspot/jtreg/gc/metaspace/TestSizeTransitions.java
index a87ed22e15b..458a90b08a4 100644
--- a/test/hotspot/jtreg/gc/metaspace/TestSizeTransitions.java
+++ b/test/hotspot/jtreg/gc/metaspace/TestSizeTransitions.java
@@ -119,8 +119,7 @@ public class TestSizeTransitions {
       System.out.println("  " + a);
     }
 
-    final ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(jvmArgs);
-    final OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    final OutputAnalyzer output = ProcessTools.executeLimitedTestJava(jvmArgs);
     System.out.println(output.getStdout());
     output.shouldHaveExitValue(0);
 
diff --git a/test/hotspot/jtreg/gc/serial/HeapChangeLogging.java b/test/hotspot/jtreg/gc/serial/HeapChangeLogging.java
index 8480d046dfb..486fdbe0ed1 100644
--- a/test/hotspot/jtreg/gc/serial/HeapChangeLogging.java
+++ b/test/hotspot/jtreg/gc/serial/HeapChangeLogging.java
@@ -41,8 +41,7 @@ import jdk.test.lib.process.OutputAnalyzer;
 
 public class HeapChangeLogging {
   public static void main(String[] args) throws Exception {
-    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-Xmx128m", "-Xmn100m", "-XX:+UseSerialGC", "-Xlog:gc", HeapFiller.class.getName());
-    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+    OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xmx128m", "-Xmn100m", "-XX:+UseSerialGC", "-Xlog:gc", HeapFiller.class.getName());
     String stdout = output.getStdout();
     System.out.println(stdout);
     Matcher stdoutMatcher = Pattern.compile(".*\\(Allocation Failure\\) [0-9]+[KMG]->[0-9]+[KMG]\\([0-9]+[KMG]\\)", Pattern.MULTILINE).matcher(stdout);
diff --git a/test/hotspot/jtreg/gc/shenandoah/TestEvilSyncBug.java b/test/hotspot/jtreg/gc/shenandoah/TestEvilSyncBug.java
index 67690d8cad5..8765105b5c0 100644
--- a/test/hotspot/jtreg/gc/shenandoah/TestEvilSyncBug.java
+++ b/test/hotspot/jtreg/gc/shenandoah/TestEvilSyncBug.java
@@ -56,14 +56,13 @@ public class TestEvilSyncBug {
 
             for (int c = 0; c < NUM_RUNS; c++) {
                 Callable<Void> task = () -> {
-                    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-Xms128m",
+                    OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xms128m",
                             "-Xmx128m",
                             "-XX:+UnlockExperimentalVMOptions",
                             "-XX:+UnlockDiagnosticVMOptions",
                             "-XX:+UseShenandoahGC",
                             "-XX:ShenandoahGCHeuristics=aggressive",
                             "TestEvilSyncBug", "test");
-                    OutputAnalyzer output = new OutputAnalyzer(pb.start());
                     output.shouldHaveExitValue(0);
                     return null;
                 };
diff --git a/test/hotspot/jtreg/gc/shenandoah/TestJcmdHeapDump.java b/test/hotspot/jtreg/gc/shenandoah/TestJcmdHeapDump.java
index cc5bc5d425e..40a36d0a5ef 100644
--- a/test/hotspot/jtreg/gc/shenandoah/TestJcmdHeapDump.java
+++ b/test/hotspot/jtreg/gc/shenandoah/TestJcmdHeapDump.java
@@ -127,6 +127,7 @@
  */
 
 import jdk.test.lib.JDKToolLauncher;
+import jdk.test.lib.process.ProcessTools;
 import jdk.test.lib.process.OutputAnalyzer;
 
 import java.io.File;
@@ -141,11 +142,7 @@ public class TestJcmdHeapDump {
         jcmd.addToolArg(dumpFileName);
 
         try {
-            ProcessBuilder pb = new ProcessBuilder(jcmd.getCommand());
-            Process jcmdProc = pb.start();
-
-            OutputAnalyzer output = new OutputAnalyzer(jcmdProc);
-            jcmdProc.waitFor();
+            OutputAnalyzer output = ProcessTools.executeProcess(jcmd.getCommand());
             output.shouldHaveExitValue(0);
         } catch (Exception e) {
             throw new RuntimeException("Test failed: " + e);
diff --git a/test/hotspot/jtreg/gc/shenandoah/TestObjItrWithHeapDump.java b/test/hotspot/jtreg/gc/shenandoah/TestObjItrWithHeapDump.java
index c0161b7a238..a0612a60a9f 100644
--- a/test/hotspot/jtreg/gc/shenandoah/TestObjItrWithHeapDump.java
+++ b/test/hotspot/jtreg/gc/shenandoah/TestObjItrWithHeapDump.java
@@ -41,9 +41,8 @@ public class TestObjItrWithHeapDump {
         String[] cmds = Arrays.copyOf(args, args.length + 2);
         cmds[args.length] = TestObjItrWithHeapDump.class.getName();
         cmds[args.length + 1] = "test";
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(cmds);
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(cmds);
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldHaveExitValue(0);
         output.shouldContain("Class Histogram (before full gc)");
         output.shouldContain("Class Histogram (after full gc)");
diff --git a/test/hotspot/jtreg/gc/shenandoah/TestPeriodicGC.java b/test/hotspot/jtreg/gc/shenandoah/TestPeriodicGC.java
index b65aa0cd0b4..3a5780069ef 100644
--- a/test/hotspot/jtreg/gc/shenandoah/TestPeriodicGC.java
+++ b/test/hotspot/jtreg/gc/shenandoah/TestPeriodicGC.java
@@ -42,9 +42,8 @@ public class TestPeriodicGC {
         String[] cmds = Arrays.copyOf(args, args.length + 2);
         cmds[args.length] = TestPeriodicGC.class.getName();
         cmds[args.length + 1] = "test";
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(cmds);
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(cmds);
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldHaveExitValue(0);
         if (periodic && !output.getOutput().contains("Trigger: Time since last GC")) {
             throw new AssertionError(msg + ": Should have periodic GC in logs");
diff --git a/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargeObj.java b/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargeObj.java
index 1057eb4a977..f9e660cb200 100644
--- a/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargeObj.java
+++ b/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargeObj.java
@@ -55,27 +55,25 @@ public class TestAllocLargeObj {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
                     "-Xmx16m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     TestAllocLargeObj.class.getName(),
                     "test");
 
-            OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
             analyzer.shouldHaveExitValue(1);
             analyzer.shouldContain("java.lang.OutOfMemoryError: Java heap space");
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
                     "-Xmx1g",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     TestAllocLargeObj.class.getName(),
                     "test");
 
-            OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
             analyzer.shouldHaveExitValue(0);
             analyzer.shouldNotContain("java.lang.OutOfMemoryError: Java heap space");
         }
diff --git a/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargerThanHeap.java b/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargerThanHeap.java
index 1567e3d05da..a87fda5c98d 100644
--- a/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargerThanHeap.java
+++ b/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargerThanHeap.java
@@ -50,27 +50,25 @@ public class TestAllocLargerThanHeap {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
                     "-Xmx16m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     TestAllocLargerThanHeap.class.getName(),
                     "test");
 
-            OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
             analyzer.shouldHaveExitValue(1);
             analyzer.shouldContain("java.lang.OutOfMemoryError: Java heap space");
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
                     "-Xmx1g",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     TestAllocLargerThanHeap.class.getName(),
                     "test");
 
-            OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
             analyzer.shouldHaveExitValue(0);
             analyzer.shouldNotContain("java.lang.OutOfMemoryError: Java heap space");
         }
diff --git a/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocSmallObj.java b/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocSmallObj.java
index bc32c1f0aa0..572351b498f 100644
--- a/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocSmallObj.java
+++ b/test/hotspot/jtreg/gc/shenandoah/oom/TestAllocSmallObj.java
@@ -54,27 +54,25 @@ public class TestAllocSmallObj {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
                     "-Xmx16m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     TestAllocSmallObj.class.getName(),
                     "test");
 
-            OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
             analyzer.shouldHaveExitValue(1);
             analyzer.shouldContain("java.lang.OutOfMemoryError: Java heap space");
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
                     "-Xmx1g",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     TestAllocSmallObj.class.getName(),
                     "test");
 
-            OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
             analyzer.shouldHaveExitValue(0);
             analyzer.shouldNotContain("java.lang.OutOfMemoryError: Java heap space");
         }
diff --git a/test/hotspot/jtreg/gc/shenandoah/oom/TestClassLoaderLeak.java b/test/hotspot/jtreg/gc/shenandoah/oom/TestClassLoaderLeak.java
index beb57b0b401..9d17e916089 100644
--- a/test/hotspot/jtreg/gc/shenandoah/oom/TestClassLoaderLeak.java
+++ b/test/hotspot/jtreg/gc/shenandoah/oom/TestClassLoaderLeak.java
@@ -99,9 +99,7 @@ public class TestClassLoaderLeak {
         pbArgs.add(TestClassLoaderLeak.class.getName());
         pbArgs.add("test");
 
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(pbArgs.toArray(new String[0]));
-
-        OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
+        OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(pbArgs.toArray(new String[0]));
 
         if (shouldPass) {
             analyzer.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/shenandoah/oom/TestThreadFailure.java b/test/hotspot/jtreg/gc/shenandoah/oom/TestThreadFailure.java
index 75cb2d5c31a..fea5761df2f 100644
--- a/test/hotspot/jtreg/gc/shenandoah/oom/TestThreadFailure.java
+++ b/test/hotspot/jtreg/gc/shenandoah/oom/TestThreadFailure.java
@@ -62,14 +62,13 @@ public class TestThreadFailure {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
                     "-Xmx32m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     TestThreadFailure.class.getName(),
                     "test");
 
-            OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
             analyzer.shouldHaveExitValue(0);
             analyzer.shouldContain("java.lang.OutOfMemoryError");
             analyzer.shouldContain("All good");
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestArgumentRanges.java b/test/hotspot/jtreg/gc/shenandoah/options/TestArgumentRanges.java
index 2cc2c2c2197..597d9a74c1d 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestArgumentRanges.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestArgumentRanges.java
@@ -46,36 +46,33 @@ public class TestArgumentRanges {
     private static void testHeuristics() throws Exception {
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:ShenandoahGCHeuristics=aggressive",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:ShenandoahGCHeuristics=static",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:ShenandoahGCHeuristics=fluff",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Unknown -XX:ShenandoahGCHeuristics option");
             output.shouldHaveExitValue(1);
         }
@@ -83,47 +80,43 @@ public class TestArgumentRanges {
 
     private static void testRange(String option, int min, int max) throws Exception {
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:" + option + "=" + (max + 1),
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(1);
         }
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:" + option + "=" + max,
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:" + option + "=" + (min - 1),
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(1);
         }
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:" + option + "=" + min,
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
     }
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestClassUnloadingArguments.java b/test/hotspot/jtreg/gc/shenandoah/options/TestClassUnloadingArguments.java
index c575b51084c..bf49ad3ec9c 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestClassUnloadingArguments.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestClassUnloadingArguments.java
@@ -43,8 +43,7 @@ public class TestClassUnloadingArguments {
         cmds[args.length] = "-Xmx128m";
         cmds[args.length + 1] = "-XX:+PrintFlagsFinal";
         cmds[args.length + 2] = "-version";
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(cmds);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(cmds);
         output.shouldHaveExitValue(0);
         output.shouldContain("ClassUnloading");
         output.shouldContain("ClassUnloadingWithConcurrentMark");
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestExplicitGC.java b/test/hotspot/jtreg/gc/shenandoah/options/TestExplicitGC.java
index 49e7c417130..7fe5d56f7de 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestExplicitGC.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestExplicitGC.java
@@ -60,14 +60,13 @@ public class TestExplicitGC {
         };
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xlog:gc",
                     TestExplicitGC.class.getName(),
                     "test");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             for (String p : full) {
                 output.shouldNotContain(p);
             }
@@ -77,7 +76,7 @@ public class TestExplicitGC {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
@@ -85,7 +84,6 @@ public class TestExplicitGC {
                     "-XX:+DisableExplicitGC",
                     TestExplicitGC.class.getName(),
                     "test");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             for (String p : full) {
                 output.shouldNotContain(p);
             }
@@ -95,7 +93,7 @@ public class TestExplicitGC {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
@@ -103,7 +101,6 @@ public class TestExplicitGC {
                     "-XX:+ExplicitGCInvokesConcurrent",
                     TestExplicitGC.class.getName(),
                     "test");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             for (String p : full) {
                 output.shouldNotContain(p);
             }
@@ -113,7 +110,7 @@ public class TestExplicitGC {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
@@ -121,7 +118,6 @@ public class TestExplicitGC {
                     "-XX:-ExplicitGCInvokesConcurrent",
                     TestExplicitGC.class.getName(),
                     "test");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             for (String p : full) {
                 output.shouldContain(p);
             }
@@ -131,7 +127,7 @@ public class TestExplicitGC {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
@@ -140,7 +136,6 @@ public class TestExplicitGC {
                     "-XX:ShenandoahGCMode=iu",
                     TestExplicitGC.class.getName(),
                     "test");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             for (String p : full) {
                 output.shouldNotContain(p);
             }
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestExplicitGCNoConcurrent.java b/test/hotspot/jtreg/gc/shenandoah/options/TestExplicitGCNoConcurrent.java
index 6499457b667..176e4a2ca7a 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestExplicitGCNoConcurrent.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestExplicitGCNoConcurrent.java
@@ -60,7 +60,7 @@ public class TestExplicitGCNoConcurrent {
         };
 
         for (String opt : opts) {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
@@ -70,7 +70,6 @@ public class TestExplicitGCNoConcurrent {
                     "-XX:ShenandoahGCHeuristics=passive",
                     TestExplicitGCNoConcurrent.class.getName(),
                     "test");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             for (String p : concurrent) {
                 output.shouldNotContain(p);
             }
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestHeuristicsUnlock.java b/test/hotspot/jtreg/gc/shenandoah/options/TestHeuristicsUnlock.java
index c9f1c75b4e1..9d0065fe803 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestHeuristicsUnlock.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestHeuristicsUnlock.java
@@ -52,7 +52,7 @@ public class TestHeuristicsUnlock {
 
     private static void testWith(String h, Mode mode) throws Exception {
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:-UnlockDiagnosticVMOptions",
                     "-XX:-UnlockExperimentalVMOptions",
@@ -60,7 +60,6 @@ public class TestHeuristicsUnlock {
                     h,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             switch (mode) {
                 case PRODUCT:
                     output.shouldHaveExitValue(0);
@@ -73,7 +72,7 @@ public class TestHeuristicsUnlock {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:-UnlockExperimentalVMOptions",
@@ -81,7 +80,6 @@ public class TestHeuristicsUnlock {
                     h,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             switch (mode) {
                 case PRODUCT:
                 case DIAGNOSTIC:
@@ -94,7 +92,7 @@ public class TestHeuristicsUnlock {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:-UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
@@ -102,7 +100,6 @@ public class TestHeuristicsUnlock {
                     h,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             switch (mode) {
                 case PRODUCT:
                 case EXPERIMENTAL:
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestHumongousThresholdArgs.java b/test/hotspot/jtreg/gc/shenandoah/options/TestHumongousThresholdArgs.java
index 523f434dbbd..47d4115ce74 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestHumongousThresholdArgs.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestHumongousThresholdArgs.java
@@ -38,12 +38,11 @@ import jdk.test.lib.process.OutputAnalyzer;
 public class TestHumongousThresholdArgs {
     public static void main(String[] args) throws Exception {
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
@@ -51,24 +50,22 @@ public class TestHumongousThresholdArgs {
         int[] invalid = new int[] {-100, -1, 0, 101, 1000};
 
         for (int v : valid) {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:ShenandoahHumongousThreshold=" + v,
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         for (int v : invalid) {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-XX:ShenandoahHumongousThreshold=" + v,
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(1);
         }
     }
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestLoopMiningArguments.java b/test/hotspot/jtreg/gc/shenandoah/options/TestLoopMiningArguments.java
index 79452b6cbc5..6d37b2877da 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestLoopMiningArguments.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestLoopMiningArguments.java
@@ -44,8 +44,7 @@ public class TestLoopMiningArguments {
         cmds[args.length] = "-Xmx128m";
         cmds[args.length + 1] = "-XX:+PrintFlagsFinal";
         cmds[args.length + 2] = "-version";
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(cmds);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(cmds);
         output.shouldHaveExitValue(0);
         output.shouldContain("UseCountedLoopSafepoints");
         output.shouldContain("LoopStripMiningIter");
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestModeUnlock.java b/test/hotspot/jtreg/gc/shenandoah/options/TestModeUnlock.java
index 0c8fea7f993..802038363b5 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestModeUnlock.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestModeUnlock.java
@@ -51,7 +51,7 @@ public class TestModeUnlock {
 
     private static void testWith(String h, Mode mode) throws Exception {
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:-UnlockDiagnosticVMOptions",
                     "-XX:-UnlockExperimentalVMOptions",
@@ -59,7 +59,6 @@ public class TestModeUnlock {
                     h,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             switch (mode) {
                 case PRODUCT:
                     output.shouldHaveExitValue(0);
@@ -72,7 +71,7 @@ public class TestModeUnlock {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:-UnlockExperimentalVMOptions",
@@ -80,7 +79,6 @@ public class TestModeUnlock {
                     h,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             switch (mode) {
                 case PRODUCT:
                 case DIAGNOSTIC:
@@ -93,7 +91,7 @@ public class TestModeUnlock {
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:-UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
@@ -101,7 +99,6 @@ public class TestModeUnlock {
                     h,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             switch (mode) {
                 case PRODUCT:
                 case EXPERIMENTAL:
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestRegionSizeArgs.java b/test/hotspot/jtreg/gc/shenandoah/options/TestRegionSizeArgs.java
index 79d0b517e89..a8d5155584b 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestRegionSizeArgs.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestRegionSizeArgs.java
@@ -45,113 +45,103 @@ public class TestRegionSizeArgs {
     private static void testInvalidRegionSizes() throws Exception {
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms4m",
                     "-Xmx1g",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms8m",
                     "-Xmx1g",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahRegionSize=200m",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahRegionSize option");
             output.shouldHaveExitValue(1);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahRegionSize=9m",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahRegionSize=255K",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahRegionSize option");
             output.shouldHaveExitValue(1);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahRegionSize=260K",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms1g",
                     "-Xmx1g",
                     "-XX:ShenandoahRegionSize=32M",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms1g",
                     "-Xmx1g",
                     "-XX:ShenandoahRegionSize=64M",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahRegionSize option");
             output.shouldHaveExitValue(1);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms1g",
                     "-Xmx1g",
                     "-XX:ShenandoahRegionSize=256K",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms1g",
                     "-Xmx1g",
                     "-XX:ShenandoahRegionSize=128K",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahRegionSize option");
             output.shouldHaveExitValue(1);
         }
@@ -160,49 +150,45 @@ public class TestRegionSizeArgs {
     private static void testMinRegionSize() throws Exception {
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahMinRegionSize=255K",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize option");
             output.shouldHaveExitValue(1);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahMinRegionSize=1M",
                     "-XX:ShenandoahMaxRegionSize=260K",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize or -XX:ShenandoahMaxRegionSize");
             output.shouldHaveExitValue(1);
         }
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahMinRegionSize=200m",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize option");
             output.shouldHaveExitValue(1);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahMinRegionSize=9m",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
@@ -211,26 +197,24 @@ public class TestRegionSizeArgs {
     private static void testMaxRegionSize() throws Exception {
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahMaxRegionSize=255K",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahMaxRegionSize option");
             output.shouldHaveExitValue(1);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms100m",
                     "-Xmx1g",
                     "-XX:ShenandoahMinRegionSize=1M",
                     "-XX:ShenandoahMaxRegionSize=260K",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize or -XX:ShenandoahMaxRegionSize");
             output.shouldHaveExitValue(1);
         }
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestSelectiveBarrierFlags.java b/test/hotspot/jtreg/gc/shenandoah/options/TestSelectiveBarrierFlags.java
index 5b34bfab3a0..094e62f53f3 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestSelectiveBarrierFlags.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestSelectiveBarrierFlags.java
@@ -89,8 +89,7 @@ public class TestSelectiveBarrierFlags {
 
             pool.submit(() -> {
                 try {
-                    ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(conf.toArray(new String[0]));
-                    OutputAnalyzer output = new OutputAnalyzer(pb.start());
+                    OutputAnalyzer output = ProcessTools.executeLimitedTestJava(conf.toArray(new String[0]));
                     output.shouldHaveExitValue(0);
                 } catch (Exception e) {
                     e.printStackTrace();
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestSoftMaxHeapSize.java b/test/hotspot/jtreg/gc/shenandoah/options/TestSoftMaxHeapSize.java
index 78bbf75189c..212ffb41037 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestSoftMaxHeapSize.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestSoftMaxHeapSize.java
@@ -38,35 +38,32 @@ import jdk.test.lib.process.OutputAnalyzer;
 public class TestSoftMaxHeapSize {
     public static void main(String[] args) throws Exception {
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms4m",
                     "-Xmx128m",
                     "-XX:SoftMaxHeapSize=4m",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms4m",
                     "-Xmx128m",
                     "-XX:SoftMaxHeapSize=128m",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions",
                     "-XX:+UseShenandoahGC",
                     "-Xms4m",
                     "-Xmx128m",
                     "-XX:SoftMaxHeapSize=129m",
                     "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(1);
             output.shouldContain("SoftMaxHeapSize must be less than or equal to the maximum heap size");
         }
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestThreadCounts.java b/test/hotspot/jtreg/gc/shenandoah/options/TestThreadCounts.java
index f7f9ee56b59..90985eb4c4d 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestThreadCounts.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestThreadCounts.java
@@ -45,7 +45,7 @@ public class TestThreadCounts {
     }
 
     private static void testWith(int conc, int par) throws Exception {
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                 "-Xmx128m",
                 "-XX:+UnlockDiagnosticVMOptions",
                 "-XX:+UnlockExperimentalVMOptions",
@@ -53,7 +53,6 @@ public class TestThreadCounts {
                 "-XX:ConcGCThreads=" + conc,
                 "-XX:ParallelGCThreads=" + par,
                 "-version");
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
         if (conc == 0) {
             output.shouldContain("Shenandoah expects ConcGCThreads > 0");
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestThreadCountsOverride.java b/test/hotspot/jtreg/gc/shenandoah/options/TestThreadCountsOverride.java
index 5e63595e726..b3d8ba34567 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestThreadCountsOverride.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestThreadCountsOverride.java
@@ -38,7 +38,7 @@ import jdk.test.lib.process.OutputAnalyzer;
 public class TestThreadCountsOverride {
     public static void main(String[] args) throws Exception {
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                 "-Xmx128m",
                 "-XX:+UnlockDiagnosticVMOptions",
                 "-XX:+UnlockExperimentalVMOptions",
@@ -46,14 +46,13 @@ public class TestThreadCountsOverride {
                 "-XX:ParallelGCThreads=1",
                 "-XX:+PrintFlagsFinal",
                 "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
             output.shouldMatch("ParallelGCThreads(.*)= 1 ");
             output.shouldHaveExitValue(0);
         }
 
         {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                 "-Xmx128m",
                 "-XX:+UnlockDiagnosticVMOptions",
                 "-XX:+UnlockExperimentalVMOptions",
@@ -61,7 +60,6 @@ public class TestThreadCountsOverride {
                 "-XX:ConcGCThreads=1",
                 "-XX:+PrintFlagsFinal",
                 "-version");
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
 
             output.shouldMatch("ConcGCThreads(.*)= 1 ");
             output.shouldHaveExitValue(0);
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierDisable.java b/test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierDisable.java
index 0e913375534..aa6b7935649 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierDisable.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierDisable.java
@@ -63,7 +63,7 @@ public class TestWrongBarrierDisable {
 
     private static void shouldFailAll(String h, String[] barriers) throws Exception {
         for (String b : barriers) {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
@@ -72,7 +72,6 @@ public class TestWrongBarrierDisable {
                     "-XX:-" + b,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldNotHaveExitValue(0);
             output.shouldContain("GC mode needs ");
             output.shouldContain("to work correctly");
@@ -81,7 +80,7 @@ public class TestWrongBarrierDisable {
 
     private static void shouldPassAll(String h, String[] barriers) throws Exception {
         for (String b : barriers) {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
@@ -90,7 +89,6 @@ public class TestWrongBarrierDisable {
                     "-XX:-" + b,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
     }
diff --git a/test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierEnable.java b/test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierEnable.java
index 84645621eb4..486860728ab 100644
--- a/test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierEnable.java
+++ b/test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierEnable.java
@@ -55,7 +55,7 @@ public class TestWrongBarrierEnable {
 
     private static void shouldFailAll(String h, String[] barriers) throws Exception {
         for (String b : barriers) {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
@@ -64,7 +64,6 @@ public class TestWrongBarrierEnable {
                     "-XX:+" + b,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldNotHaveExitValue(0);
             output.shouldContain("GC mode needs ");
             output.shouldContain("to work correctly");
@@ -73,7 +72,7 @@ public class TestWrongBarrierEnable {
 
     private static void shouldPassAll(String h, String[] barriers) throws Exception {
         for (String b : barriers) {
-            ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(
+            OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
                     "-Xmx128m",
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+UnlockExperimentalVMOptions",
@@ -82,7 +81,6 @@ public class TestWrongBarrierEnable {
                     "-XX:+" + b,
                     "-version"
             );
-            OutputAnalyzer output = new OutputAnalyzer(pb.start());
             output.shouldHaveExitValue(0);
         }
     }
diff --git a/test/hotspot/jtreg/gc/stress/TestReclaimStringsLeaksMemory.java b/test/hotspot/jtreg/gc/stress/TestReclaimStringsLeaksMemory.java
index 83f211ad5fa..bfe19e2c9c5 100644
--- a/test/hotspot/jtreg/gc/stress/TestReclaimStringsLeaksMemory.java
+++ b/test/hotspot/jtreg/gc/stress/TestReclaimStringsLeaksMemory.java
@@ -61,8 +61,8 @@ public class TestReclaimStringsLeaksMemory {
                                                                    "-XX:+PrintNMTStatistics" ));
         baseargs.addAll(Arrays.asList(args));
         baseargs.add(GCTest.class.getName());
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(baseargs);
-        verifySymbolMemoryUsageNotTooHigh(new OutputAnalyzer(pb.start()));
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(baseargs);
+        verifySymbolMemoryUsageNotTooHigh(output);
     }
 
     private static void verifySymbolMemoryUsageNotTooHigh(OutputAnalyzer output) throws Exception {
diff --git a/test/hotspot/jtreg/gc/stress/TestStressG1Humongous.java b/test/hotspot/jtreg/gc/stress/TestStressG1Humongous.java
index 2a02039c60e..70544e8af31 100644
--- a/test/hotspot/jtreg/gc/stress/TestStressG1Humongous.java
+++ b/test/hotspot/jtreg/gc/stress/TestStressG1Humongous.java
@@ -101,8 +101,7 @@ public class TestStressG1Humongous{
                 "-Dregionsize=" + regionSize,
                 TestStressG1HumongousImpl.class.getName()
         );
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(options);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(options);
         output.shouldHaveExitValue(0);
     }
 }
diff --git a/test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java b/test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java
index 2f61c166cb8..d3575e8cd4b 100644
--- a/test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java
+++ b/test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java
@@ -59,8 +59,7 @@ public class TestStressG1Uncommit {
             "-XX:+UseG1GC",
             StressUncommit.class.getName()
         );
-        ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(options);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeLimitedTestJava(options);
         output.shouldHaveExitValue(0);
         output.shouldMatch("Uncommit regions");
         output.outputTo(System.out);
diff --git a/test/hotspot/jtreg/gc/stringdedup/TestStringDeduplicationTools.java b/test/hotspot/jtreg/gc/stringdedup/TestStringDeduplicationTools.java
index 31c11b66dfc..8b8fea1f2e3 100644
--- a/test/hotspot/jtreg/gc/stringdedup/TestStringDeduplicationTools.java
+++ b/test/hotspot/jtreg/gc/stringdedup/TestStringDeduplicationTools.java
@@ -299,8 +299,7 @@ class TestStringDeduplicationTools {
         args.addAll(Arrays.asList(defaultArgs));
         args.addAll(Arrays.asList(extraArgs));
 
-        ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(args);
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeTestJava(args);
         System.err.println(output.getStderr());
         System.out.println(output.getStdout());
         return output;
diff --git a/test/hotspot/jtreg/gc/testlibrary/Helpers.java b/test/hotspot/jtreg/gc/testlibrary/Helpers.java
index 225a5bda0e6..03d67e44455 100644
--- a/test/hotspot/jtreg/gc/testlibrary/Helpers.java
+++ b/test/hotspot/jtreg/gc/testlibrary/Helpers.java
@@ -25,6 +25,7 @@ package gc.testlibrary;
 
 import jdk.test.lib.JDKToolLauncher;
 import jdk.test.lib.process.OutputAnalyzer;
+import jdk.test.lib.process.ProcessTools;
 import jdk.test.whitebox.WhiteBox;
 
 import java.io.File;
@@ -89,7 +90,7 @@ public class Helpers {
      * @param source    class source
      * @throws IOException if cannot write file to specified directory
      */
-    public static void compileClass(String className, Path root, String source) throws IOException {
+    public static void compileClass(String className, Path root, String source) throws Exception {
         Path sourceFile = root.resolve(className + ".java");
         Files.write(sourceFile, source.getBytes());
 
@@ -100,8 +101,7 @@ public class Helpers {
                 .addToolArg(System.getProperty("java.class.path") + File.pathSeparator + root.toAbsolutePath())
                 .addToolArg(sourceFile.toAbsolutePath().toString());
 
-        ProcessBuilder pb = new ProcessBuilder(jar.getCommand());
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        OutputAnalyzer output = ProcessTools.executeProcess(jar.getCommand());
         output.shouldHaveExitValue(0);
     }
 
@@ -199,12 +199,11 @@ public class Helpers {
      * @param prefix       prefix for service classes (ones we use to create chain of inheritance).
      *                     The names will be prefix_1, prefix_2,.., prefix_n
      * @return Class object of generated and compiled class loaded in specified class loader
-     * @throws IOException
-     * @throws ClassNotFoundException
+     * @throws Exception
      */
     public static Class<?> generateCompileAndLoad(ClassLoader classLoader, String className, long instanceSize,
                                                   Path workDir, String prefix)
-            throws IOException, ClassNotFoundException {
+            throws Exception {
 
         generateByTemplateAndCompile(className, null, "public class ${ClassName} extends ${BaseClass} {\n${Fields}}\n",
                 "", instanceSize, workDir, prefix);
@@ -243,11 +242,11 @@ public class Helpers {
      * @param prefix       prefix for service classes (ones we use to create chain of inheritance).
      *                     The names will be prefix_1, prefix_2,.., prefix_n
      * @return Class object of generated and compiled class loaded in specified class loader
-     * @throws IOException if cannot write or read to workDir
+     * @throws Exception if cannot write or read to workDir
      */
     public static void generateByTemplateAndCompile(String className, String baseClass, String classTemplate,
                                                     String constructorTemplate, long instanceSize, Path workDir,
-                                                    String prefix) throws IOException {
+                                                    String prefix) throws Exception {
 
         if (instanceSize % SIZE_OF_LONG != 0L) {
             throw new Error(String.format("Test bug: only sizes aligned by %d bytes are supported and %d was specified",
diff --git a/test/hotspot/jtreg/gc/whitebox/TestWBGC.java b/test/hotspot/jtreg/gc/whitebox/TestWBGC.java
index c2fe2633e4e..38f3593b638 100644
--- a/test/hotspot/jtreg/gc/whitebox/TestWBGC.java
+++ b/test/hotspot/jtreg/gc/whitebox/TestWBGC.java
@@ -43,7 +43,7 @@ import jdk.test.whitebox.WhiteBox;
 public class TestWBGC {
 
     public static void main(String args[]) throws Exception {
-        ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
+        OutputAnalyzer output = ProcessTools.executeTestJava(
                 "-Xbootclasspath/a:.",
                 "-XX:+UnlockDiagnosticVMOptions",
                 "-XX:+WhiteBoxAPI",
@@ -51,7 +51,6 @@ public class TestWBGC {
                 "-Xlog:gc",
                 GCYoungTest.class.getName());
 
-        OutputAnalyzer output = new OutputAnalyzer(pb.start());
         System.out.println(output.getStdout());
         output.shouldHaveExitValue(0);
         output.shouldContain("WhiteBox Initiated Young GC");
diff --git a/test/hotspot/jtreg/gc/x/TestAllocateHeapAt.java b/test/hotspot/jtreg/gc/x/TestAllocateHeapAt.java
index de3d1f585a7..3bf83d90768 100644
--- a/test/hotspot/jtreg/gc/x/TestAllocateHeapAt.java
+++ b/test/hotspot/jtreg/gc/x/TestAllocateHeapAt.java
@@ -41,16 +41,16 @@ public class TestAllocateHeapAt {
         final String heapBackingFile = "Heap Backing File: " + directory;
         final String failedToCreateFile = "Failed to create file " + directory;
 
-        ProcessTools.executeProcess(ProcessTools.createLimitedTestJavaProcessBuilder(
-                "-XX:+UseZGC",
-                "-XX:-ZGenerational",
-                "-Xlog:gc*",
-                "-Xms32M",
-                "-Xmx32M",
-                "-XX:AllocateHeapAt=" + directory,
-                "-version"))
-            .shouldContain(exists ? heapBackingFile : failedToCreateFile)
-            .shouldNotContain(exists ? failedToCreateFile : heapBackingFile)
-            .shouldHaveExitValue(exists ? 0 : 1);
+        ProcessTools.executeLimitedTestJava(
+            "-XX:+UseZGC",
+            "-XX:-ZGenerational",
+            "-Xlog:gc*",
+            "-Xms32M",
+            "-Xmx32M",
+            "-XX:AllocateHeapAt=" + directory,
+            "-version")
+                .shouldContain(exists ? heapBackingFile : failedToCreateFile)
+                .shouldNotContain(exists ? failedToCreateFile : heapBackingFile)
+                .shouldHaveExitValue(exists ? 0 : 1);
     }
 }
diff --git a/test/hotspot/jtreg/gc/x/TestPageCacheFlush.java b/test/hotspot/jtreg/gc/x/TestPageCacheFlush.java
index 5a20ee8322a..cb8685d0d09 100644
--- a/test/hotspot/jtreg/gc/x/TestPageCacheFlush.java
+++ b/test/hotspot/jtreg/gc/x/TestPageCacheFlush.java
@@ -68,16 +68,16 @@ public class TestPageCacheFlush {
     }
 
     public static void main(String[] args) throws Exception {
-        ProcessTools.executeProcess(ProcessTools.createLimitedTestJavaProcessBuilder(
-                                    "-XX:+UseZGC",
-                                    "-XX:-ZGenerational",
-                                    "-Xms128M",
-                                    "-Xmx128M",
-                                    "-Xlog:gc,gc+init,gc+heap=debug",
-                                    Test.class.getName()))
-                    .outputTo(System.out)
-                    .errorTo(System.out)
-                    .shouldContain("Page Cache Flushed:")
-                    .shouldHaveExitValue(0);
+        ProcessTools.executeLimitedTestJava(
+            "-XX:+UseZGC",
+            "-XX:-ZGenerational",
+            "-Xms128M",
+            "-Xmx128M",
+            "-Xlog:gc,gc+init,gc+heap=debug",
+            Test.class.getName())
+                .outputTo(System.out)
+                .errorTo(System.out)
+                .shouldContain("Page Cache Flushed:")
+                .shouldHaveExitValue(0);
     }
 }
diff --git a/test/hotspot/jtreg/gc/x/TestSmallHeap.java b/test/hotspot/jtreg/gc/x/TestSmallHeap.java
index 0fc6477b59b..8fc6f07be39 100644
--- a/test/hotspot/jtreg/gc/x/TestSmallHeap.java
+++ b/test/hotspot/jtreg/gc/x/TestSmallHeap.java
@@ -53,16 +53,16 @@ public class TestSmallHeap {
 
     public static void main(String[] args) throws Exception {
         for (var maxCapacity: args) {
-            ProcessTools.executeProcess(ProcessTools.createLimitedTestJavaProcessBuilder(
-                                        "-XX:+UseZGC",
-                                        "-XX:-ZGenerational",
-                                        "-Xlog:gc,gc+init,gc+reloc,gc+heap",
-                                        "-Xmx" + maxCapacity,
-                                        Test.class.getName()))
-                .outputTo(System.out)
-                .errorTo(System.out)
-                .shouldContain("Success")
-                .shouldHaveExitValue(0);
+            ProcessTools.executeLimitedTestJava(
+                "-XX:+UseZGC",
+                "-XX:-ZGenerational",
+                "-Xlog:gc,gc+init,gc+reloc,gc+heap",
+                "-Xmx" + maxCapacity,
+                Test.class.getName())
+                    .outputTo(System.out)
+                    .errorTo(System.out)
+                    .shouldContain("Success")
+                    .shouldHaveExitValue(0);
         }
     }
 }
diff --git a/test/hotspot/jtreg/gc/z/TestAllocateHeapAt.java b/test/hotspot/jtreg/gc/z/TestAllocateHeapAt.java
index f5a6113f6ff..9f47c4b60d3 100644
--- a/test/hotspot/jtreg/gc/z/TestAllocateHeapAt.java
+++ b/test/hotspot/jtreg/gc/z/TestAllocateHeapAt.java
@@ -41,16 +41,16 @@ public class TestAllocateHeapAt {
         final String heapBackingFile = "Heap Backing File: " + directory;
         final String failedToCreateFile = "Failed to create file " + directory;
 
-        ProcessTools.executeProcess(ProcessTools.createLimitedTestJavaProcessBuilder(
-                "-XX:+UseZGC",
-                "-XX:+ZGenerational",
-                "-Xlog:gc*",
-                "-Xms32M",
-                "-Xmx32M",
-                "-XX:AllocateHeapAt=" + directory,
-                "-version"))
-            .shouldContain(exists ? heapBackingFile : failedToCreateFile)
-            .shouldNotContain(exists ? failedToCreateFile : heapBackingFile)
-            .shouldHaveExitValue(exists ? 0 : 1);
+        ProcessTools.executeLimitedTestJava(
+            "-XX:+UseZGC",
+            "-XX:+ZGenerational",
+            "-Xlog:gc*",
+            "-Xms32M",
+            "-Xmx32M",
+            "-XX:AllocateHeapAt=" + directory,
+            "-version")
+                .shouldContain(exists ? heapBackingFile : failedToCreateFile)
+                .shouldNotContain(exists ? failedToCreateFile : heapBackingFile)
+                .shouldHaveExitValue(exists ? 0 : 1);
     }
 }
diff --git a/test/hotspot/jtreg/gc/z/TestPageCacheFlush.java b/test/hotspot/jtreg/gc/z/TestPageCacheFlush.java
index 629edccd496..387053b580a 100644
--- a/test/hotspot/jtreg/gc/z/TestPageCacheFlush.java
+++ b/test/hotspot/jtreg/gc/z/TestPageCacheFlush.java
@@ -68,16 +68,16 @@ public class TestPageCacheFlush {
     }
 
     public static void main(String[] args) throws Exception {
-        ProcessTools.executeProcess(ProcessTools.createLimitedTestJavaProcessBuilder(
-                                    "-XX:+UseZGC",
-                                    "-XX:+ZGenerational",
-                                    "-Xms128M",
-                                    "-Xmx128M",
-                                    "-Xlog:gc,gc+init,gc+heap=debug",
-                                    Test.class.getName()))
-                    .outputTo(System.out)
-                    .errorTo(System.out)
-                    .shouldContain("Page Cache Flushed:")
-                    .shouldHaveExitValue(0);
+        ProcessTools.executeLimitedTestJava(
+            "-XX:+UseZGC",
+            "-XX:+ZGenerational",
+            "-Xms128M",
+            "-Xmx128M",
+            "-Xlog:gc,gc+init,gc+heap=debug",
+            Test.class.getName())
+                .outputTo(System.out)
+                .errorTo(System.out)
+                .shouldContain("Page Cache Flushed:")
+                .shouldHaveExitValue(0);
     }
 }
diff --git a/test/hotspot/jtreg/gc/z/TestSmallHeap.java b/test/hotspot/jtreg/gc/z/TestSmallHeap.java
index bfe1c0310ca..354cd4164f1 100644
--- a/test/hotspot/jtreg/gc/z/TestSmallHeap.java
+++ b/test/hotspot/jtreg/gc/z/TestSmallHeap.java
@@ -53,16 +53,16 @@ public class TestSmallHeap {
 
     public static void main(String[] args) throws Exception {
         for (var maxCapacity: args) {
-            ProcessTools.executeProcess(ProcessTools.createLimitedTestJavaProcessBuilder(
-                                        "-XX:+UseZGC",
-                                        "-XX:+ZGenerational",
-                                        "-Xlog:gc,gc+init,gc+reloc,gc+heap",
-                                        "-Xmx" + maxCapacity,
-                                        Test.class.getName()))
-                .outputTo(System.out)
-                .errorTo(System.out)
-                .shouldContain("Success")
-                .shouldHaveExitValue(0);
+            ProcessTools.executeLimitedTestJava(
+                "-XX:+UseZGC",
+                "-XX:+ZGenerational",
+                "-Xlog:gc,gc+init,gc+reloc,gc+heap",
+                "-Xmx" + maxCapacity,
+                Test.class.getName())
+                    .outputTo(System.out)
+                    .errorTo(System.out)
+                    .shouldContain("Success")
+                    .shouldHaveExitValue(0);
         }
     }
 }
diff --git a/test/hotspot/jtreg/gc/z/TestZForceDiscontiguousHeapReservations.java b/test/hotspot/jtreg/gc/z/TestZForceDiscontiguousHeapReservations.java
index 2993038faa5..f1a14f0cf90 100644
--- a/test/hotspot/jtreg/gc/z/TestZForceDiscontiguousHeapReservations.java
+++ b/test/hotspot/jtreg/gc/z/TestZForceDiscontiguousHeapReservations.java
@@ -45,17 +45,17 @@ public class TestZForceDiscontiguousHeapReservations {
          */
         final int XmxInM = 2000;
         final int XmsInM = Math.min(16 * XmxInM / (n + 1), XmxInM);
-        OutputAnalyzer oa = ProcessTools.executeProcess(ProcessTools.createTestJavaProcessBuilder(
-                                                        "-XX:+UseZGC",
-                                                        "-XX:+ZGenerational",
-                                                        "-Xms" + XmsInM + "M",
-                                                        "-Xmx" + XmxInM + "M",
-                                                        "-Xlog:gc,gc+init",
-                                                        "-XX:ZForceDiscontiguousHeapReservations=" + n,
-                                                        "-version"))
-                                        .outputTo(System.out)
-                                        .errorTo(System.out)
-                                        .shouldHaveExitValue(0);
+        OutputAnalyzer oa = ProcessTools.executeTestJava(
+            "-XX:+UseZGC",
+            "-XX:+ZGenerational",
+            "-Xms" + XmsInM + "M",
+            "-Xmx" + XmxInM + "M",
+            "-Xlog:gc,gc+init",
+            "-XX:ZForceDiscontiguousHeapReservations=" + n,
+            "-version")
+                .outputTo(System.out)
+                .errorTo(System.out)
+                .shouldHaveExitValue(0);
         if (n > 1) {
             oa.shouldContain("Address Space Type: Discontiguous");
         }
diff --git a/test/hotspot/jtreg/gc/z/TestZNMT.java b/test/hotspot/jtreg/gc/z/TestZNMT.java
index 066ebd063f6..db37a0e1e14 100644
--- a/test/hotspot/jtreg/gc/z/TestZNMT.java
+++ b/test/hotspot/jtreg/gc/z/TestZNMT.java
@@ -68,21 +68,21 @@ public class TestZNMT {
          *   reservations.
          */
         final int XmsInM = Math.min(16 * XmxInM / (zForceDiscontiguousHeapReservations + 1), XmxInM);
-        OutputAnalyzer oa = ProcessTools.executeProcess(ProcessTools.createTestJavaProcessBuilder(
-                                                        "-XX:+UseZGC",
-                                                        "-XX:+ZGenerational",
-                                                        "-Xms" + XmsInM + "M",
-                                                        "-Xmx" + XmxInM + "M",
-                                                        "-Xlog:gc,gc+init",
-                                                        "-XX:ZForceDiscontiguousHeapReservations=" + zForceDiscontiguousHeapReservations,
-                                                        "-XX:NativeMemoryTracking=detail",
-                                                        "-XX:+PrintNMTStatistics",
-                                                        Test.class.getName(),
-                                                        Integer.toString(zForceDiscontiguousHeapReservations),
-                                                        Integer.toString(XmxInM)))
-                                        .outputTo(System.out)
-                                        .errorTo(System.out)
-                                        .shouldHaveExitValue(0);
+        OutputAnalyzer oa = ProcessTools.executeTestJava(
+            "-XX:+UseZGC",
+            "-XX:+ZGenerational",
+            "-Xms" + XmsInM + "M",
+            "-Xmx" + XmxInM + "M",
+            "-Xlog:gc,gc+init",
+            "-XX:ZForceDiscontiguousHeapReservations=" + zForceDiscontiguousHeapReservations,
+            "-XX:NativeMemoryTracking=detail",
+            "-XX:+PrintNMTStatistics",
+            Test.class.getName(),
+            Integer.toString(zForceDiscontiguousHeapReservations),
+            Integer.toString(XmxInM))
+                .outputTo(System.out)
+                .errorTo(System.out)
+                .shouldHaveExitValue(0);
         if (zForceDiscontiguousHeapReservations > 1) {
             oa.shouldContain("Address Space Type: Discontiguous");
         }