stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Reviewed-by: tschatzl, aboldtch
This commit is contained in:
Stefan Karlsson 2024-01-05 09:12:24 +00:00
parent 868f8745fa
commit 1d1cd32bc3
132 changed files with 471 additions and 664 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
test/hotspot/jtreg/gc/TestAgeOutput.java
View File

@ -66,7 +66,7 @@ public class TestAgeOutput {
} }
public static void runTest(String gcArg) throws Exception { public static void runTest(String gcArg) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
@ -75,7 +75,6 @@ public class TestAgeOutput {
"-Xmx10M", "-Xmx10M",
"-Xlog:gc+age=trace", "-Xlog:gc+age=trace",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

3
test/hotspot/jtreg/gc/TestAllocateHeapAt.java
View File

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

3
test/hotspot/jtreg/gc/TestAllocateHeapAtError.java
View File

@ -45,13 +45,12 @@ public class TestAllocateHeapAtError {
f = new File(test_dir, UUID.randomUUID().toString()); f = new File(test_dir, UUID.randomUUID().toString());
} while(f.exists()); } while(f.exists());
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeTestJava(
"-XX:AllocateHeapAt=" + f.getName(), "-XX:AllocateHeapAt=" + f.getName(),
"-Xlog:gc+heap=info", "-Xlog:gc+heap=info",
"-Xmx32m", "-Xmx32m",
"-Xms32m", "-Xms32m",
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println("Output:\n" + output.getOutput()); System.out.println("Output:\n" + output.getOutput());

3
test/hotspot/jtreg/gc/TestAllocateHeapAtMultiple.java
View File

@ -60,8 +60,7 @@ public class TestAllocateHeapAtMultiple {
"-Xlog:gc+heap=info", "-Xlog:gc+heap=info",
"-version"}); "-version"});
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(flags); OutputAnalyzer output = ProcessTools.executeTestJava(flags);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println("Output:\n" + output.getOutput()); System.out.println("Output:\n" + output.getOutput());

3
test/hotspot/jtreg/gc/TestCardTablePageCommits.java
View File

@ -42,12 +42,11 @@ public class TestCardTablePageCommits {
// because of 8kB pages, assume 4 KB pages for all other CPUs. // because of 8kB pages, assume 4 KB pages for all other CPUs.
String Xmx = "-Xmx4m"; String Xmx = "-Xmx4m";
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
Xmx, Xmx,
"-XX:NativeMemoryTracking=detail", "-XX:NativeMemoryTracking=detail",
"-XX:+UseParallelGC", "-XX:+UseParallelGC",
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
} }

3
test/hotspot/jtreg/gc/TestNumWorkerOutput.java
View File

@ -58,7 +58,7 @@ public class TestNumWorkerOutput {
} }
public static void runTest(String gcArg) throws Exception { public static void runTest(String gcArg) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
@ -67,7 +67,6 @@ public class TestNumWorkerOutput {
"-Xmx10M", "-Xmx10M",
"-XX:+PrintGCDetails", "-XX:+PrintGCDetails",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

4
test/hotspot/jtreg/gc/TestPLABAdaptToMinTLABSize.java
View File

@ -48,9 +48,7 @@ public class TestPLABAdaptToMinTLABSize {
Collections.addAll(testArguments, extraArgs); Collections.addAll(testArguments, extraArgs);
testArguments.add("-version"); testArguments.add("-version");
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(testArguments); OutputAnalyzer output = ProcessTools.executeTestJava(testArguments);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStderr()); System.out.println(output.getStderr());

3
test/hotspot/jtreg/gc/TestSmallHeap.java
View File

@ -96,12 +96,11 @@ public class TestSmallHeap {
private static void verifySmallHeapSize(String gc, long expectedMaxHeap) throws Exception { private static void verifySmallHeapSize(String gc, long expectedMaxHeap) throws Exception {
long minMaxHeap = 4 * 1024 * 1024; long minMaxHeap = 4 * 1024 * 1024;
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
gc, gc,
"-Xmx" + minMaxHeap, "-Xmx" + minMaxHeap,
"-XX:+PrintFlagsFinal", "-XX:+PrintFlagsFinal",
VerifyHeapSize.class.getName()); VerifyHeapSize.class.getName());
OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);
expectedMaxHeap = Math.max(expectedMaxHeap, minMaxHeap); expectedMaxHeap = Math.max(expectedMaxHeap, minMaxHeap);

3
test/hotspot/jtreg/gc/TestVerifyDuringStartup.java
View File

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

3
test/hotspot/jtreg/gc/TestVerifySilently.java
View File

@ -57,8 +57,7 @@ public class TestVerifySilently {
"-XX:+VerifyAfterGC", "-XX:+VerifyAfterGC",
(verifySilently ? "-Xlog:gc":"-Xlog:gc+verify=debug"), (verifySilently ? "-Xlog:gc":"-Xlog:gc+verify=debug"),
TestVerifySilentlyRunSystemGC.class.getName()}); TestVerifySilentlyRunSystemGC.class.getName()});
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(vmOpts); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(vmOpts);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println("Output:\n" + output.getOutput()); System.out.println("Output:\n" + output.getOutput());
return output; return output;

3
test/hotspot/jtreg/gc/TestVerifySubSet.java
View File

@ -59,8 +59,7 @@ public class TestVerifySubSet {
"-Xlog:gc+verify=debug", "-Xlog:gc+verify=debug",
"-XX:VerifySubSet="+subset, "-XX:VerifySubSet="+subset,
TestVerifySubSetRunSystemGC.class.getName()}); TestVerifySubSetRunSystemGC.class.getName()});
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(vmOpts); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(vmOpts);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println("Output:\n" + output.getOutput()); System.out.println("Output:\n" + output.getOutput());
return output; return output;

17
test/hotspot/jtreg/gc/arguments/GCArguments.java
View File

@ -27,6 +27,7 @@ import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import jdk.test.lib.Platform; import jdk.test.lib.Platform;
import jdk.test.lib.process.OutputAnalyzer;
import jdk.test.lib.process.ProcessTools; import jdk.test.lib.process.ProcessTools;
/** /**
@ -81,4 +82,20 @@ public final class GCArguments {
static public ProcessBuilder createTestJavaProcessBuilder(String... arguments) { static public ProcessBuilder createTestJavaProcessBuilder(String... arguments) {
return ProcessTools.createTestJavaProcessBuilder(withDefaults(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));
}
} }

4
test/hotspot/jtreg/gc/arguments/TestAggressiveHeap.java
View File

@ -65,11 +65,9 @@ public class TestAggressiveHeap {
" *bool +UseParallelGC *= *true +\\{product\\} *\\{command line\\}"; " *bool +UseParallelGC *= *true +\\{product\\} *\\{command line\\}";
private static void testFlag() throws Exception { private static void testFlag() throws Exception {
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder( OutputAnalyzer output = GCArguments.executeTestJava(
option, heapSizeOption, "-XX:+PrintFlagsFinal", "-version"); option, heapSizeOption, "-XX:+PrintFlagsFinal", "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String value = output.firstMatch(parallelGCPattern); String value = output.firstMatch(parallelGCPattern);

12
test/hotspot/jtreg/gc/arguments/TestCompressedClassFlags.java
View File

@ -41,17 +41,13 @@ import jdk.test.lib.Platform;
public class TestCompressedClassFlags { public class TestCompressedClassFlags {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
if (Platform.is64bit()) { if (Platform.is64bit()) {
OutputAnalyzer output = runJava("-XX:CompressedClassSpaceSize=1g", OutputAnalyzer output = GCArguments.executeTestJava(
"-XX:-UseCompressedClassPointers", "-XX:CompressedClassSpaceSize=1g",
"-version"); "-XX:-UseCompressedClassPointers",
"-version");
output.shouldContain("warning"); output.shouldContain("warning");
output.shouldNotContain("error"); output.shouldNotContain("error");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
} }
private static OutputAnalyzer runJava(String ... args) throws Exception {
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(args);
return new OutputAnalyzer(pb.start());
}
} }

15
test/hotspot/jtreg/gc/arguments/TestDisableDefaultGC.java
View File

@ -40,14 +40,13 @@ import jdk.test.lib.process.OutputAnalyzer;
public class TestDisableDefaultGC { public class TestDisableDefaultGC {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
// Start VM, disabling all possible default GCs // Start VM, disabling all possible default GCs
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder("-XX:-UseSerialGC", OutputAnalyzer output = GCArguments.executeTestJava("-XX:-UseSerialGC",
"-XX:-UseParallelGC", "-XX:-UseParallelGC",
"-XX:-UseG1GC", "-XX:-UseG1GC",
"-XX:-UseZGC", "-XX:-UseZGC",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:-UseShenandoahGC", "-XX:-UseShenandoahGC",
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldMatch("Garbage collector not selected"); output.shouldMatch("Garbage collector not selected");
output.shouldHaveExitValue(1); output.shouldHaveExitValue(1);
} }

3
test/hotspot/jtreg/gc/arguments/TestG1ConcMarkStepDurationMillis.java
View File

@ -78,8 +78,7 @@ public class TestG1ConcMarkStepDurationMillis {
Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:G1ConcMarkStepDurationMillis="+expectedValue, "-XX:+PrintFlagsFinal", "-version"); Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:G1ConcMarkStepDurationMillis="+expectedValue, "-XX:+PrintFlagsFinal", "-version");
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(vmOpts); OutputAnalyzer output = GCArguments.executeTestJava(vmOpts);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(expectedResult == PASS ? 0 : 1); output.shouldHaveExitValue(expectedResult == PASS ? 0 : 1);
String stdout = output.getStdout(); String stdout = output.getStdout();

3
test/hotspot/jtreg/gc/arguments/TestG1ConcRefinementThreads.java
View File

@ -69,8 +69,7 @@ public class TestG1ConcRefinementThreads {
} }
Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:+PrintFlagsFinal", "-version"); Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:+PrintFlagsFinal", "-version");
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(vmOpts); OutputAnalyzer output = GCArguments.executeTestJava(vmOpts);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String stdout = output.getStdout(); String stdout = output.getStdout();

3
test/hotspot/jtreg/gc/arguments/TestG1HeapRegionSize.java
View File

@ -53,8 +53,7 @@ public class TestG1HeapRegionSize {
flagList.add("-XX:+PrintFlagsFinal"); flagList.add("-XX:+PrintFlagsFinal");
flagList.add("-version"); flagList.add("-version");
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(flagList); OutputAnalyzer output = GCArguments.executeTestJava(flagList);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(exitValue); output.shouldHaveExitValue(exitValue);
if (exitValue == 0) { if (exitValue == 0) {

3
test/hotspot/jtreg/gc/arguments/TestG1PercentageOptions.java
View File

@ -63,8 +63,7 @@ public class TestG1PercentageOptions {
}; };
private static void check(String flag, boolean is_valid) throws Exception { private static void check(String flag, boolean is_valid) throws Exception {
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder("-XX:+UseG1GC", flag, "-version"); OutputAnalyzer output = GCArguments.executeTestJava("-XX:+UseG1GC", flag, "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
if (is_valid) { if (is_valid) {
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} else { } else {

3
test/hotspot/jtreg/gc/arguments/TestG1RemSetFlags.java
View File

@ -48,8 +48,7 @@ public class TestG1RemSetFlags {
flagList.add("-XX:+PrintFlagsFinal"); flagList.add("-XX:+PrintFlagsFinal");
flagList.add("-version"); flagList.add("-version");
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(flagList); OutputAnalyzer output = GCArguments.executeTestJava(flagList);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(exitValue); output.shouldHaveExitValue(exitValue);
} }

3
test/hotspot/jtreg/gc/arguments/TestHeapFreeRatio.java
View File

@ -48,11 +48,10 @@ public class TestHeapFreeRatio {
} }
private static void testMinMaxFreeRatio(String min, String max, Validation type) throws Exception { private static void testMinMaxFreeRatio(String min, String max, Validation type) throws Exception {
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder( OutputAnalyzer output = GCArguments.executeTestJava(
"-Xminf" + min, "-Xminf" + min,
"-Xmaxf" + max, "-Xmaxf" + max,
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
switch (type) { switch (type) {
case VALID: case VALID:

6
test/hotspot/jtreg/gc/arguments/TestInitialTenuringThreshold.java
View File

@ -41,14 +41,13 @@ import jdk.test.lib.process.OutputAnalyzer;
public class TestInitialTenuringThreshold { public class TestInitialTenuringThreshold {
public static void runWithThresholds(int initial, int max, boolean shouldfail) throws Exception { public static void runWithThresholds(int initial, int max, boolean shouldfail) throws Exception {
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder( OutputAnalyzer output = GCArguments.executeTestJava(
"-XX:+UseParallelGC", "-XX:+UseParallelGC",
"-XX:InitialTenuringThreshold=" + String.valueOf(initial), "-XX:InitialTenuringThreshold=" + String.valueOf(initial),
"-XX:MaxTenuringThreshold=" + String.valueOf(max), "-XX:MaxTenuringThreshold=" + String.valueOf(max),
"-version" "-version"
); );
OutputAnalyzer output = new OutputAnalyzer(pb.start());
if (shouldfail) { if (shouldfail) {
output.shouldHaveExitValue(1); output.shouldHaveExitValue(1);
} else { } else {
@ -58,14 +57,13 @@ public class TestInitialTenuringThreshold {
public static void main(String args[]) throws Exception { 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 // some value below the default value of InitialTenuringThreshold of 7
"-XX:+UseParallelGC", "-XX:+UseParallelGC",
"-XX:MaxTenuringThreshold=1", "-XX:MaxTenuringThreshold=1",
"-version" "-version"
); );
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
// successful tests // successful tests
runWithThresholds(0, 10, false); runWithThresholds(0, 10, false);

9
test/hotspot/jtreg/gc/arguments/TestMaxHeapSizeTools.java
View File

@ -115,9 +115,8 @@ class TestMaxHeapSizeTools {
} }
private static void getNewOldSize(String gcflag, long[] values) throws Exception { private static void getNewOldSize(String gcflag, long[] values) throws Exception {
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(gcflag, OutputAnalyzer output = GCArguments.executeTestJava(gcflag,
"-XX:+PrintFlagsFinal", "-version"); "-XX:+PrintFlagsFinal", "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String stdout = output.getStdout(); String stdout = output.getStdout();
@ -208,8 +207,7 @@ class TestMaxHeapSizeTools {
finalargs.add(classname); finalargs.add(classname);
finalargs.addAll(Arrays.asList(arguments)); finalargs.addAll(Arrays.asList(arguments));
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(finalargs.toArray(String[]::new)); OutputAnalyzer output = GCArguments.executeTestJava(finalargs.toArray(String[]::new));
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
return output; return output;
@ -308,8 +306,7 @@ class TestMaxHeapSizeTools {
} }
private static void expect(String[] flags, boolean hasWarning, boolean hasError, int errorcode) throws Exception { private static void expect(String[] flags, boolean hasWarning, boolean hasError, int errorcode) throws Exception {
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(flags); OutputAnalyzer output = GCArguments.executeTestJava(flags);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
shouldContainOrNot(output, hasWarning, "Warning"); shouldContainOrNot(output, hasWarning, "Warning");
shouldContainOrNot(output, hasError, "Error"); shouldContainOrNot(output, hasError, "Error");
output.shouldHaveExitValue(errorcode); output.shouldHaveExitValue(errorcode);

6
test/hotspot/jtreg/gc/arguments/TestMaxMinHeapFreeRatioFlags.java
View File

@ -98,8 +98,7 @@ public class TestMaxMinHeapFreeRatioFlags {
Boolean.toString(shrinkHeapInSteps) Boolean.toString(shrinkHeapInSteps)
); );
ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions); OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);
} }
@ -123,8 +122,7 @@ public class TestMaxMinHeapFreeRatioFlags {
"--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED", "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED",
"-version" "-version"
); );
ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions); OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
analyzer.shouldHaveExitValue(1); analyzer.shouldHaveExitValue(1);
analyzer.shouldContain("Error: Could not create the Java Virtual Machine."); analyzer.shouldContain("Error: Could not create the Java Virtual Machine.");
} }

3
test/hotspot/jtreg/gc/arguments/TestMaxNewSize.java
View File

@ -95,8 +95,7 @@ public class TestMaxNewSize {
finalargs.add("-XX:+PrintFlagsFinal"); finalargs.add("-XX:+PrintFlagsFinal");
finalargs.add("-version"); finalargs.add("-version");
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder(finalargs); OutputAnalyzer output = GCArguments.executeTestJava(finalargs);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String stdout = output.getStdout(); String stdout = output.getStdout();
return getFlagValue("MaxNewSize", stdout); return getFlagValue("MaxNewSize", stdout);

6
test/hotspot/jtreg/gc/arguments/TestMaxRAMFlags.java
View File

@ -61,8 +61,7 @@ public class TestMaxRAMFlags {
args.add("-XX:+PrintFlagsFinal"); args.add("-XX:+PrintFlagsFinal");
args.add("-version"); args.add("-version");
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(args); OutputAnalyzer output = GCArguments.executeLimitedTestJava(args);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String stdout = output.getStdout(); String stdout = output.getStdout();
@ -84,8 +83,7 @@ public class TestMaxRAMFlags {
args.add("-XX:+PrintFlagsFinal"); args.add("-XX:+PrintFlagsFinal");
args.add("-version"); args.add("-version");
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(args); OutputAnalyzer output = GCArguments.executeLimitedTestJava(args);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String stdout = output.getStdout(); String stdout = output.getStdout();
return (new Long(getFlagValue("HeapBaseMinAddress", stdout)).longValue()); return (new Long(getFlagValue("HeapBaseMinAddress", stdout)).longValue());

3
test/hotspot/jtreg/gc/arguments/TestMinAndInitialSurvivorRatioFlags.java
View File

@ -102,8 +102,7 @@ public class TestMinAndInitialSurvivorRatioFlags {
Boolean.toString(useAdaptiveSizePolicy) Boolean.toString(useAdaptiveSizePolicy)
); );
vmOptions.removeIf((String p) -> p.isEmpty()); vmOptions.removeIf((String p) -> p.isEmpty());
ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions); OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);
} }

3
test/hotspot/jtreg/gc/arguments/TestNewRatioFlag.java
View File

@ -82,8 +82,7 @@ public class TestNewRatioFlag {
Integer.toString(ratio) Integer.toString(ratio)
); );
ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions); OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);
System.out.println(analyzer.getOutput()); System.out.println(analyzer.getOutput());
} }

8
test/hotspot/jtreg/gc/arguments/TestNewSizeFlags.java
View File

@ -133,7 +133,7 @@ public class TestNewSizeFlags {
long heapSize, long maxHeapSize, long heapSize, long maxHeapSize,
long expectedNewSize, long expectedMaxNewSize, long expectedNewSize, long expectedMaxNewSize,
LinkedList<String> options, boolean failureExpected) throws Exception { 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) { if (failureExpected) {
analyzer.shouldHaveExitValue(1); 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 newSize, long maxNewSize,
long heapSize, long maxHeapSize, long heapSize, long maxHeapSize,
long expectedNewSize, long expectedMaxNewSize) throws Exception, IOException { long expectedNewSize, long expectedMaxNewSize) throws Exception, IOException {
@ -166,9 +166,7 @@ public class TestNewSizeFlags {
Long.toString(maxHeapSize) Long.toString(maxHeapSize)
); );
vmOptions.removeIf(String::isEmpty); vmOptions.removeIf(String::isEmpty);
ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions); return GCArguments.executeLimitedTestJava(vmOptions);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
return analyzer;
} }
/** /**

15
test/hotspot/jtreg/gc/arguments/TestNewSizeThreadIncrease.java
View File

@ -65,14 +65,13 @@ public class TestNewSizeThreadIncrease {
} }
static void runNewSizeThreadIncreaseTest(String expectedValue, boolean isNewsizeChanged) throws Exception { static void runNewSizeThreadIncreaseTest(String expectedValue, boolean isNewsizeChanged) throws Exception {
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder("-XX:+UseSerialGC", OutputAnalyzer output = GCArguments.executeLimitedTestJava("-XX:+UseSerialGC",
"-Xms96M", "-Xms96M",
"-Xmx128M", "-Xmx128M",
"-XX:NewRatio=2", "-XX:NewRatio=2",
"-Xlog:gc+heap+ergo=debug", "-Xlog:gc+heap+ergo=debug",
"-XX:NewSizeThreadIncrease="+expectedValue, "-XX:NewSizeThreadIncrease="+expectedValue,
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

3
test/hotspot/jtreg/gc/arguments/TestObjectTenuringFlags.java
View File

@ -161,8 +161,7 @@ public class TestObjectTenuringFlags {
} }
Collections.addAll(vmOpts, "-XX:+UseParallelGC", "-XX:+PrintFlagsFinal", "-version"); Collections.addAll(vmOpts, "-XX:+UseParallelGC", "-XX:+PrintFlagsFinal", "-version");
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(vmOpts); OutputAnalyzer output = GCArguments.executeLimitedTestJava(vmOpts);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
if (shouldFail) { if (shouldFail) {
output.shouldHaveExitValue(1); output.shouldHaveExitValue(1);

9
test/hotspot/jtreg/gc/arguments/TestParallelGCThreads.java
View File

@ -56,10 +56,9 @@ public class TestParallelGCThreads {
private static final String printFlagsFinalPattern = " *uint *" + flagName + " *:?= *(\\d+) *\\{product\\} *"; private static final String printFlagsFinalPattern = " *uint *" + flagName + " *:?= *(\\d+) *\\{product\\} *";
public static void testDefaultValue() throws Exception { public static void testDefaultValue() throws Exception {
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = GCArguments.executeLimitedTestJava(
"-XX:+UnlockExperimentalVMOptions", "-XX:+PrintFlagsFinal", "-version"); "-XX:+UnlockExperimentalVMOptions", "-XX:+PrintFlagsFinal", "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
String value = output.firstMatch(printFlagsFinalPattern, 1); String value = output.firstMatch(printFlagsFinalPattern, 1);
try { try {
@ -94,12 +93,11 @@ public class TestParallelGCThreads {
for (String gc : supportedGC) { for (String gc : supportedGC) {
// Make sure the VM does not allow ParallelGCThreads set to 0 // Make sure the VM does not allow ParallelGCThreads set to 0
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = GCArguments.executeLimitedTestJava(
"-XX:+Use" + gc + "GC", "-XX:+Use" + gc + "GC",
"-XX:ParallelGCThreads=0", "-XX:ParallelGCThreads=0",
"-XX:+PrintFlagsFinal", "-XX:+PrintFlagsFinal",
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(1); output.shouldHaveExitValue(1);
// Do some basic testing to ensure the flag updates the count // 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 { public static long getParallelGCThreadCount(String... flags) throws Exception {
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(flags); OutputAnalyzer output = GCArguments.executeLimitedTestJava(flags);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String stdout = output.getStdout(); String stdout = output.getStdout();
return FlagsValue.getFlagLongValue("ParallelGCThreads", stdout); return FlagsValue.getFlagLongValue("ParallelGCThreads", stdout);

4
test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java
View File

@ -77,9 +77,7 @@ public class TestParallelRefProc {
result.addAll(Arrays.asList(args)); result.addAll(Arrays.asList(args));
result.add("-XX:+PrintFlagsFinal"); result.add("-XX:+PrintFlagsFinal");
result.add("-version"); result.add("-version");
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(result); OutputAnalyzer output = GCArguments.executeLimitedTestJava(result);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

3
test/hotspot/jtreg/gc/arguments/TestSelectDefaultGC.java
View File

@ -44,12 +44,11 @@ public class TestSelectDefaultGC {
public static void testDefaultGC(boolean actAsServer) throws Exception { public static void testDefaultGC(boolean actAsServer) throws Exception {
// Start VM without specifying GC // Start VM without specifying GC
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = GCArguments.executeLimitedTestJava(
"-XX:" + (actAsServer ? "+" : "-") + "AlwaysActAsServerClassMachine", "-XX:" + (actAsServer ? "+" : "-") + "AlwaysActAsServerClassMachine",
"-XX:" + (actAsServer ? "-" : "+") + "NeverActAsServerClassMachine", "-XX:" + (actAsServer ? "-" : "+") + "NeverActAsServerClassMachine",
"-XX:+PrintFlagsFinal", "-XX:+PrintFlagsFinal",
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
final boolean isServer = actAsServer; final boolean isServer = actAsServer;

3
test/hotspot/jtreg/gc/arguments/TestSmallInitialHeapWithLargePageAndNUMA.java
View File

@ -60,14 +60,13 @@ public class TestSmallInitialHeapWithLargePageAndNUMA {
long initHeap = heapAlignment; long initHeap = heapAlignment;
long maxHeap = heapAlignment * 2; long maxHeap = heapAlignment * 2;
ProcessBuilder pb_enabled = GCArguments.createLimitedTestJavaProcessBuilder( OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(
"-XX:+UseParallelGC", "-XX:+UseParallelGC",
"-Xms" + String.valueOf(initHeap), "-Xms" + String.valueOf(initHeap),
"-Xmx" + String.valueOf(maxHeap), "-Xmx" + String.valueOf(maxHeap),
"-XX:+UseNUMA", "-XX:+UseNUMA",
"-XX:+PrintFlagsFinal", "-XX:+PrintFlagsFinal",
"-version"); "-version");
OutputAnalyzer analyzer = new OutputAnalyzer(pb_enabled.start());
if (largePageOrNumaEnabled(analyzer)) { if (largePageOrNumaEnabled(analyzer)) {
// We reach here, if both NUMA and HugeTLB are supported. // We reach here, if both NUMA and HugeTLB are supported.

3
test/hotspot/jtreg/gc/arguments/TestSurvivorRatioFlag.java
View File

@ -87,8 +87,7 @@ public class TestSurvivorRatioFlag {
Integer.toString(ratio) Integer.toString(ratio)
); );
ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions); OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);
} }

6
test/hotspot/jtreg/gc/arguments/TestTargetSurvivorRatioFlag.java
View File

@ -116,8 +116,7 @@ public class TestTargetSurvivorRatioFlag {
vmOptions.add("-XX:TargetSurvivorRatio=" + ratio); vmOptions.add("-XX:TargetSurvivorRatio=" + ratio);
vmOptions.add("-version"); vmOptions.add("-version");
ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions); OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
analyzer.shouldHaveExitValue(1); analyzer.shouldHaveExitValue(1);
analyzer.shouldContain("Error: Could not create the Java Virtual Machine."); analyzer.shouldContain("Error: Could not create the Java Virtual Machine.");
@ -151,8 +150,7 @@ public class TestTargetSurvivorRatioFlag {
Integer.toString(ratio) Integer.toString(ratio)
); );
ProcessBuilder procBuilder = GCArguments.createLimitedTestJavaProcessBuilder(vmOptions); OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);

9
test/hotspot/jtreg/gc/arguments/TestUnrecognizedVMOptionsHandling.java
View File

@ -40,32 +40,29 @@ public class TestUnrecognizedVMOptionsHandling {
public static void main(String args[]) throws Exception { public static void main(String args[]) throws Exception {
// The first two JAVA processes are expected to fail, but with a correct VM option suggestion // 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", "-XX:+UseDynamicNumberOfGcThreads",
"-version" "-version"
); );
OutputAnalyzer outputWithError = new OutputAnalyzer(pb.start());
outputWithError.shouldContain("Did you mean '(+/-)UseDynamicNumberOfGCThreads'?"); outputWithError.shouldContain("Did you mean '(+/-)UseDynamicNumberOfGCThreads'?");
if (outputWithError.getExitValue() == 0) { if (outputWithError.getExitValue() == 0) {
throw new RuntimeException("Not expected to get exit value 0"); throw new RuntimeException("Not expected to get exit value 0");
} }
pb = GCArguments.createLimitedTestJavaProcessBuilder( outputWithError = GCArguments.executeLimitedTestJava(
"-XX:MaxiumHeapSize=500m", "-XX:MaxiumHeapSize=500m",
"-version" "-version"
); );
outputWithError = new OutputAnalyzer(pb.start());
outputWithError.shouldContain("Did you mean 'MaxHeapSize=<value>'?"); outputWithError.shouldContain("Did you mean 'MaxHeapSize=<value>'?");
if (outputWithError.getExitValue() == 0) { if (outputWithError.getExitValue() == 0) {
throw new RuntimeException("Not expected to get exit value 0"); throw new RuntimeException("Not expected to get exit value 0");
} }
// The last JAVA process should run successfully for the purpose of sanity check // The last JAVA process should run successfully for the purpose of sanity check
pb = GCArguments.createLimitedTestJavaProcessBuilder( OutputAnalyzer outputWithNoError = GCArguments.executeLimitedTestJava(
"-XX:+UseDynamicNumberOfGCThreads", "-XX:+UseDynamicNumberOfGCThreads",
"-version" "-version"
); );
OutputAnalyzer outputWithNoError = new OutputAnalyzer(pb.start());
outputWithNoError.shouldNotContain("Did you mean '(+/-)UseDynamicNumberOfGCThreads'?"); outputWithNoError.shouldNotContain("Did you mean '(+/-)UseDynamicNumberOfGCThreads'?");
outputWithNoError.shouldHaveExitValue(0); outputWithNoError.shouldHaveExitValue(0);
} }

6
test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsErgoTools.java
View File

@ -93,8 +93,7 @@ class TestUseCompressedOopsErgoTools {
finalargs.add(classname); finalargs.add(classname);
finalargs.addAll(Arrays.asList(arguments)); finalargs.addAll(Arrays.asList(arguments));
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(finalargs); OutputAnalyzer output = GCArguments.executeLimitedTestJava(finalargs);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
return output; return output;
} }
@ -157,8 +156,7 @@ class TestUseCompressedOopsErgoTools {
} }
private static String expect(String[] flags, boolean hasWarning, boolean hasError, int errorcode) throws Exception { private static String expect(String[] flags, boolean hasWarning, boolean hasError, int errorcode) throws Exception {
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(flags); OutputAnalyzer output = GCArguments.executeLimitedTestJava(flags);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(errorcode); output.shouldHaveExitValue(errorcode);
return output.getStdout(); return output.getStdout();
} }

5
test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsFlagsWithUlimit.java
View File

@ -59,9 +59,8 @@ public class TestUseCompressedOopsFlagsWithUlimit {
// Convert bytes to kbytes for ulimit -v // Convert bytes to kbytes for ulimit -v
var ulimit_prefix = "ulimit -v " + (ulimit / 1024); var ulimit_prefix = "ulimit -v " + (ulimit / 1024);
String cmd = ProcessTools.getCommandLine(ProcessTools.createTestJavaProcessBuilder(args.toArray(String[]::new))); String cmd = ProcessTools.getCommandLine(ProcessTools.createTestJavaProcessBuilder(args));
ProcessBuilder pb = new ProcessBuilder("sh", "-c", ulimit_prefix + ";" + cmd); OutputAnalyzer output = ProcessTools.executeProcess("sh", "-c", ulimit_prefix + ";" + cmd);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String stdout = output.getStdout(); String stdout = output.getStdout();

3
test/hotspot/jtreg/gc/arguments/TestUseNUMAInterleaving.java
View File

@ -39,11 +39,10 @@ import jdk.test.lib.process.OutputAnalyzer;
public class TestUseNUMAInterleaving { public class TestUseNUMAInterleaving {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = GCArguments.createTestJavaProcessBuilder( OutputAnalyzer output = GCArguments.executeTestJava(
"-XX:+UseNUMA", "-XX:+UseNUMA",
"-XX:+PrintFlagsFinal", "-XX:+PrintFlagsFinal",
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
boolean isNUMAEnabled boolean isNUMAEnabled
= Boolean.parseBoolean(output.firstMatch(NUMA_FLAG_PATTERN, 1)); = Boolean.parseBoolean(output.firstMatch(NUMA_FLAG_PATTERN, 1));

3
test/hotspot/jtreg/gc/arguments/TestVerifyBeforeAndAfterGCFlags.java
View File

@ -99,8 +99,7 @@ public class TestVerifyBeforeAndAfterGCFlags {
: "-XX:-VerifyAfterGC"), : "-XX:-VerifyAfterGC"),
GarbageProducer.class.getName(), GarbageProducer.class.getName(),
doFullGC ? "t" : "f" }); doFullGC ? "t" : "f" });
ProcessBuilder pb = GCArguments.createLimitedTestJavaProcessBuilder(vmOpts); OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOpts);
OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);
analyzer.shouldNotMatch(VERIFY_BEFORE_GC_CORRUPTED_PATTERN); analyzer.shouldNotMatch(VERIFY_BEFORE_GC_CORRUPTED_PATTERN);

3
test/hotspot/jtreg/gc/class_unloading/TestG1ClassUnloadingHWM.java
View File

@ -45,7 +45,7 @@ public class TestG1ClassUnloadingHWM {
private static long YoungGenSize = 32 * 1024 * 1024; private static long YoungGenSize = 32 * 1024 * 1024;
private static OutputAnalyzer run(boolean enableUnloading) throws Exception { private static OutputAnalyzer run(boolean enableUnloading) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( return ProcessTools.executeLimitedTestJava(
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI", "-XX:+WhiteBoxAPI",
@ -57,7 +57,6 @@ public class TestG1ClassUnloadingHWM {
TestG1ClassUnloadingHWM.AllocateBeyondMetaspaceSize.class.getName(), TestG1ClassUnloadingHWM.AllocateBeyondMetaspaceSize.class.getName(),
"" + MetaspaceSize, "" + MetaspaceSize,
"" + YoungGenSize); "" + YoungGenSize);
return new OutputAnalyzer(pb.start());
} }
public static OutputAnalyzer runWithG1ClassUnloading() throws Exception { public static OutputAnalyzer runWithG1ClassUnloading() throws Exception {

6
test/hotspot/jtreg/gc/epsilon/TestDieDefault.java
View File

@ -37,15 +37,13 @@ import jdk.test.lib.process.ProcessTools;
public class TestDieDefault { public class TestDieDefault {
public static void passWith(String... args) throws Exception { public static void passWith(String... args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args); OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
OutputAnalyzer out = new OutputAnalyzer(pb.start());
out.shouldNotContain("OutOfMemoryError"); out.shouldNotContain("OutOfMemoryError");
out.shouldHaveExitValue(0); out.shouldHaveExitValue(0);
} }
public static void failWith(String... args) throws Exception { public static void failWith(String... args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args); OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
OutputAnalyzer out = new OutputAnalyzer(pb.start());
out.shouldContain("OutOfMemoryError"); out.shouldContain("OutOfMemoryError");
if (out.getExitValue() == 0) { if (out.getExitValue() == 0) {
throw new IllegalStateException("Should have failed with non-zero exit code"); throw new IllegalStateException("Should have failed with non-zero exit code");

3
test/hotspot/jtreg/gc/epsilon/TestDieWithHeapDump.java
View File

@ -38,8 +38,7 @@ import jdk.test.lib.process.ProcessTools;
public class TestDieWithHeapDump { public class TestDieWithHeapDump {
public static void passWith(String... args) throws Exception { public static void passWith(String... args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args); OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
OutputAnalyzer out = new OutputAnalyzer(pb.start());
out.shouldNotContain("OutOfMemoryError"); out.shouldNotContain("OutOfMemoryError");
out.shouldHaveExitValue(0); out.shouldHaveExitValue(0);
} }

6
test/hotspot/jtreg/gc/epsilon/TestDieWithOnError.java
View File

@ -39,16 +39,14 @@ public class TestDieWithOnError {
static String ON_ERR_MSG = "Epsilon error handler message"; static String ON_ERR_MSG = "Epsilon error handler message";
public static void passWith(String... args) throws Exception { public static void passWith(String... args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args); OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
OutputAnalyzer out = new OutputAnalyzer(pb.start());
out.shouldNotContain("OutOfMemoryError"); out.shouldNotContain("OutOfMemoryError");
out.stdoutShouldNotMatch("^" + ON_ERR_MSG); out.stdoutShouldNotMatch("^" + ON_ERR_MSG);
out.shouldHaveExitValue(0); out.shouldHaveExitValue(0);
} }
public static void failWith(String... args) throws Exception { public static void failWith(String... args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(args); OutputAnalyzer out = ProcessTools.executeLimitedTestJava(args);
OutputAnalyzer out = new OutputAnalyzer(pb.start());
out.shouldContain("OutOfMemoryError"); out.shouldContain("OutOfMemoryError");
if (out.getExitValue() == 0) { if (out.getExitValue() == 0) {
throw new IllegalStateException("Should have failed with non-zero exit code"); throw new IllegalStateException("Should have failed with non-zero exit code");

8
test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java
View File

@ -68,16 +68,16 @@ public class TestDynamicNumberOfGCThreads {
String[] baseArgs = {"-XX:+UnlockExperimentalVMOptions", "-XX:+" + gcFlag, "-Xmx10M", "-XX:+UseDynamicNumberOfGCThreads", "-Xlog:gc+task=trace", GCTest.class.getName()}; String[] baseArgs = {"-XX:+UnlockExperimentalVMOptions", "-XX:+" + gcFlag, "-Xmx10M", "-XX:+UseDynamicNumberOfGCThreads", "-Xlog:gc+task=trace", GCTest.class.getName()};
// Base test with gc and +UseDynamicNumberOfGCThreads: // Base test with gc and +UseDynamicNumberOfGCThreads:
ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder(baseArgs); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(baseArgs);
verifyDynamicNumberOfGCThreads(new OutputAnalyzer(pb_enabled.start())); verifyDynamicNumberOfGCThreads(output);
// Turn on parallel reference processing // Turn on parallel reference processing
String[] parRefProcArg = {"-XX:+ParallelRefProcEnabled", "-XX:-ShowMessageBoxOnError"}; String[] parRefProcArg = {"-XX:+ParallelRefProcEnabled", "-XX:-ShowMessageBoxOnError"};
String[] parRefArgs = new String[baseArgs.length + parRefProcArg.length]; String[] parRefArgs = new String[baseArgs.length + parRefProcArg.length];
System.arraycopy(parRefProcArg, 0, parRefArgs, 0, parRefProcArg.length); System.arraycopy(parRefProcArg, 0, parRefArgs, 0, parRefProcArg.length);
System.arraycopy(baseArgs, 0, parRefArgs, parRefProcArg.length, baseArgs.length); System.arraycopy(baseArgs, 0, parRefArgs, parRefProcArg.length, baseArgs.length);
pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder(parRefArgs); output = ProcessTools.executeLimitedTestJava(parRefArgs);
verifyDynamicNumberOfGCThreads(new OutputAnalyzer(pb_enabled.start())); verifyDynamicNumberOfGCThreads(output);
} }
static class GCTest { static class GCTest {

4
test/hotspot/jtreg/gc/ergonomics/TestInitialGCThreadLogging.java
View File

@ -70,13 +70,13 @@ public class TestInitialGCThreadLogging {
private static void testInitialGCThreadLogging(String gcFlag, String threadName) throws Exception { private static void testInitialGCThreadLogging(String gcFlag, String threadName) throws Exception {
// Base test with gc and +UseDynamicNumberOfGCThreads: // Base test with gc and +UseDynamicNumberOfGCThreads:
ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+" + gcFlag, "-XX:+" + gcFlag,
"-Xmx10M", "-Xmx10M",
"-XX:+UseDynamicNumberOfGCThreads", "-XX:+UseDynamicNumberOfGCThreads",
"-Xlog:gc+task=trace", "-Xlog:gc+task=trace",
"-version"); "-version");
verifyDynamicNumberOfGCThreads(new OutputAnalyzer(pb_enabled.start()), threadName); verifyDynamicNumberOfGCThreads(output, threadName);
} }
} }

3
test/hotspot/jtreg/gc/g1/Test2GbHeap.java
View File

@ -49,9 +49,8 @@ public class Test2GbHeap {
testArguments.add("-Xmx2g"); testArguments.add("-Xmx2g");
testArguments.add("-version"); testArguments.add("-version");
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(testArguments); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(testArguments);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
} }

19
test/hotspot/jtreg/gc/g1/TestAllocationFailure.java
View File

@ -43,17 +43,16 @@ import jdk.test.lib.process.ProcessTools;
public class TestAllocationFailure { public class TestAllocationFailure {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx32M", "-Xmx32M",
"-Xmn16M", "-Xmn16M",
"-XX:+G1GCAllocationFailureALot", "-XX:+G1GCAllocationFailureALot",
"-XX:G1GCAllocationFailureALotCount=100", "-XX:G1GCAllocationFailureALotCount=100",
"-XX:G1GCAllocationFailureALotInterval=1", "-XX:G1GCAllocationFailureALotInterval=1",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-Xlog:gc", "-Xlog:gc",
GCTestWithAllocationFailure.class.getName()); GCTestWithAllocationFailure.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStdout()); System.out.println(output.getStdout());
output.shouldContain("(Evacuation Failure:"); output.shouldContain("(Evacuation Failure:");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

4
test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegions.java
View File

@ -80,7 +80,7 @@ class TestEagerReclaimHumongousRegionsReclaimRegionFast {
public class TestEagerReclaimHumongousRegions { public class TestEagerReclaimHumongousRegions {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-Xms128M", "-Xms128M",
"-Xmx128M", "-Xmx128M",
@ -90,8 +90,6 @@ public class TestEagerReclaimHumongousRegions {
Pattern p = Pattern.compile("Full GC"); Pattern p = Pattern.compile("Full GC");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
int found = 0; int found = 0;
Matcher m = p.matcher(output.getStdout()); Matcher m = p.matcher(output.getStdout());
while (m.find()) { found++; } while (m.find()) { found++; }

3
test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java
View File

@ -119,7 +119,7 @@ class TestEagerReclaimHumongousRegionsClearMarkBitsReclaimRegionFast {
public class TestEagerReclaimHumongousRegionsClearMarkBits { public class TestEagerReclaimHumongousRegionsClearMarkBits {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-Xms128M", "-Xms128M",
"-Xmx128M", "-Xmx128M",
@ -132,7 +132,6 @@ public class TestEagerReclaimHumongousRegionsClearMarkBits {
"-XX:ConcGCThreads=1", // Want to make marking as slow as possible. "-XX:ConcGCThreads=1", // Want to make marking as slow as possible.
"-XX:+G1VerifyBitmaps", "-XX:+G1VerifyBitmaps",
TestEagerReclaimHumongousRegionsClearMarkBitsReclaimRegionFast.class.getName()); TestEagerReclaimHumongousRegionsClearMarkBitsReclaimRegionFast.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
} }

3
test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsLog.java
View File

@ -54,7 +54,7 @@ public class TestEagerReclaimHumongousRegionsLog {
} }
public static void runTest() throws Exception { public static void runTest() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
@ -65,7 +65,6 @@ public class TestEagerReclaimHumongousRegionsLog {
"-Xmx128M", "-Xmx128M",
"-Xlog:gc+phases=trace,gc+heap=info", "-Xlog:gc+phases=trace,gc+heap=info",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

4
test/hotspot/jtreg/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java
View File

@ -92,7 +92,7 @@ class TestEagerReclaimHumongousRegionsWithRefsReclaimRegionFast {
public class TestEagerReclaimHumongousRegionsWithRefs { public class TestEagerReclaimHumongousRegionsWithRefs {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-Xms128M", "-Xms128M",
"-Xmx128M", "-Xmx128M",
@ -102,8 +102,6 @@ public class TestEagerReclaimHumongousRegionsWithRefs {
Pattern p = Pattern.compile("Full GC"); Pattern p = Pattern.compile("Full GC");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
int found = 0; int found = 0;
Matcher m = p.matcher(output.getStdout()); Matcher m = p.matcher(output.getStdout());
while (m.find()) { while (m.find()) {

3
test/hotspot/jtreg/gc/g1/TestG1SkipCompaction.java
View File

@ -54,8 +54,7 @@ public class TestG1SkipCompaction {
"-XX:G1HeapRegionSize=1m", "-XX:G1HeapRegionSize=1m",
GCTest.class.getName() GCTest.class.getName()
}; };
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(arguments); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(arguments);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStdout()); System.out.println(output.getStdout());
String pattern = ".*skip compaction region.*"; String pattern = ".*skip compaction region.*";

18
test/hotspot/jtreg/gc/g1/TestG1TraceEagerReclaimHumongousObjects.java
View File

@ -41,16 +41,14 @@ import java.util.LinkedList;
public class TestG1TraceEagerReclaimHumongousObjects { public class TestG1TraceEagerReclaimHumongousObjects {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xms128M", "-Xms128M",
"-Xmx128M", "-Xmx128M",
"-Xmn16M", "-Xmn16M",
"-XX:G1HeapRegionSize=1M", "-XX:G1HeapRegionSize=1M",
"-Xlog:gc+phases=trace,gc+humongous=trace", "-Xlog:gc+phases=trace,gc+humongous=trace",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
GCWithHumongousObjectTest.class.getName()); GCWithHumongousObjectTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStdout()); System.out.println(output.getStdout());
// As G1ReclaimDeadHumongousObjectsAtYoungGC is set(default), below logs should be displayed. // As G1ReclaimDeadHumongousObjectsAtYoungGC is set(default), below logs should be displayed.

98
test/hotspot/jtreg/gc/g1/TestGCLogMessages.java
View File

@ -218,28 +218,25 @@ public class TestGCLogMessages {
private void testNormalLogs() throws Exception { private void testNormalLogs() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx10M", "-Xmx10M",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
checkMessagesAtLevel(output, allLogMessages, Level.OFF); checkMessagesAtLevel(output, allLogMessages, Level.OFF);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx10M", "-Xmx10M",
"-Xlog:gc+phases=debug", "-Xlog:gc+phases=debug",
GCTest.class.getName()); GCTest.class.getName());
output = new OutputAnalyzer(pb.start());
checkMessagesAtLevel(output, allLogMessages, Level.DEBUG); checkMessagesAtLevel(output, allLogMessages, Level.DEBUG);
pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx10M", "-Xmx10M",
"-Xlog:gc+phases=trace", "-Xlog:gc+phases=trace",
GCTest.class.getName()); GCTest.class.getName());
output = new OutputAnalyzer(pb.start());
checkMessagesAtLevel(output, allLogMessages, Level.TRACE); checkMessagesAtLevel(output, allLogMessages, Level.TRACE);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
@ -253,11 +250,10 @@ public class TestGCLogMessages {
}; };
private void testConcurrentRefinementLogs() throws Exception { private void testConcurrentRefinementLogs() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx10M", "-Xmx10M",
"-Xlog:gc+refine+stats=debug", "-Xlog:gc+refine+stats=debug",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
checkMessagesAtLevel(output, concRefineMessages, Level.DEBUG); checkMessagesAtLevel(output, concRefineMessages, Level.DEBUG);
} }
@ -272,29 +268,27 @@ public class TestGCLogMessages {
}; };
private void testWithEvacuationFailureLogs() throws Exception { private void testWithEvacuationFailureLogs() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx32M", "-Xmx32M",
"-Xmn16M", "-Xmn16M",
"-XX:+G1GCAllocationFailureALot", "-XX:+G1GCAllocationFailureALot",
"-XX:G1GCAllocationFailureALotCount=100", "-XX:G1GCAllocationFailureALotCount=100",
"-XX:G1GCAllocationFailureALotInterval=1", "-XX:G1GCAllocationFailureALotInterval=1",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-Xlog:gc+phases=debug", "-Xlog:gc+phases=debug",
GCTestWithAllocationFailure.class.getName()); GCTestWithAllocationFailure.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
checkMessagesAtLevel(output, exhFailureMessages, Level.DEBUG); checkMessagesAtLevel(output, exhFailureMessages, Level.DEBUG);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx32M", "-Xmx32M",
"-Xmn16M", "-Xmn16M",
"-Xms32M", "-Xms32M",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-Xlog:gc+phases=trace", "-Xlog:gc+phases=trace",
GCTestWithAllocationFailure.class.getName()); GCTestWithAllocationFailure.class.getName());
output = new OutputAnalyzer(pb.start());
checkMessagesAtLevel(output, exhFailureMessages, Level.TRACE); checkMessagesAtLevel(output, exhFailureMessages, Level.TRACE);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
@ -305,29 +299,27 @@ public class TestGCLogMessages {
}; };
private void testWithConcurrentStart() throws Exception { private void testWithConcurrentStart() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx10M", "-Xmx10M",
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-Xlog:gc*=debug", "-Xlog:gc*=debug",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI", "-XX:+WhiteBoxAPI",
GCTestWithConcurrentStart.class.getName()); GCTestWithConcurrentStart.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
checkMessagesAtLevel(output, concurrentStartMessages, Level.TRACE); checkMessagesAtLevel(output, concurrentStartMessages, Level.TRACE);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
private void testExpandHeap() throws Exception { private void testExpandHeap() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-Xmx10M", "-Xmx10M",
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-Xlog:gc+ergo+heap=debug", "-Xlog:gc+ergo+heap=debug",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI", "-XX:+WhiteBoxAPI",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Expand the heap. requested expansion amount: "); output.shouldContain("Expand the heap. requested expansion amount: ");
output.shouldContain("B expansion amount: "); output.shouldContain("B expansion amount: ");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

3
test/hotspot/jtreg/gc/g1/TestHumongousAllocConcurrentStart.java
View File

@ -45,7 +45,7 @@ public class TestHumongousAllocConcurrentStart {
private static final int initiatingHeapOccupancyPercent = 50; // % private static final int initiatingHeapOccupancyPercent = 50; // %
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeTestJava(
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-Xms" + heapSize + "m", "-Xms" + heapSize + "m",
"-Xmx" + heapSize + "m", "-Xmx" + heapSize + "m",
@ -54,7 +54,6 @@ public class TestHumongousAllocConcurrentStart {
"-Xlog:gc", "-Xlog:gc",
HumongousObjectAllocator.class.getName()); HumongousObjectAllocator.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)"); output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)");
output.shouldNotContain("Full GC"); output.shouldNotContain("Full GC");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

3
test/hotspot/jtreg/gc/g1/TestHumongousAllocNearlyFullRegion.java
View File

@ -47,7 +47,7 @@ public class TestHumongousAllocNearlyFullRegion {
private static final int heapRegionSize = 1; // MB private static final int heapRegionSize = 1; // MB
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-Xms" + heapSize + "m", "-Xms" + heapSize + "m",
"-Xmx" + heapSize + "m", "-Xmx" + heapSize + "m",
@ -55,7 +55,6 @@ public class TestHumongousAllocNearlyFullRegion {
"-Xlog:gc", "-Xlog:gc",
HumongousObjectAllocator.class.getName()); HumongousObjectAllocator.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)"); output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }

3
test/hotspot/jtreg/gc/g1/TestHumongousCodeCacheRoots.java
View File

@ -106,8 +106,7 @@ public class TestHumongousCodeCacheRoots {
finalargs.add(classname); finalargs.add(classname);
finalargs.addAll(Arrays.asList(arguments)); finalargs.addAll(Arrays.asList(arguments));
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(finalargs); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(finalargs);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
return output; return output;
} }

3
test/hotspot/jtreg/gc/g1/TestHumongousConcurrentStartUndo.java
View File

@ -56,7 +56,7 @@ public class TestHumongousConcurrentStartUndo {
private static final int YoungSize = HeapSize / 8; private static final int YoungSize = HeapSize / 8;
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-Xms" + HeapSize + "m", "-Xms" + HeapSize + "m",
@ -70,7 +70,6 @@ public class TestHumongousConcurrentStartUndo {
"-Xlog:gc*", "-Xlog:gc*",
EdenObjectAllocatorWithHumongousAllocation.class.getName()); EdenObjectAllocatorWithHumongousAllocation.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)"); output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)");
output.shouldContain("Concurrent Undo Cycle"); output.shouldContain("Concurrent Undo Cycle");
output.shouldContain("Concurrent Mark Cycle"); output.shouldContain("Concurrent Mark Cycle");

8
test/hotspot/jtreg/gc/g1/TestLargePageUseForAuxMemory.java
View File

@ -120,12 +120,9 @@ public class TestLargePageUseForAuxMemory {
static void testVM(String what, long heapsize, boolean cardsShouldUseLargePages, boolean bitmapShouldUseLargePages) throws Exception { 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 + " " + System.out.println(what + " heapsize " + heapsize + " card table should use large pages " + cardsShouldUseLargePages + " " +
"bitmaps should use large pages " + bitmapShouldUseLargePages); "bitmaps should use large pages " + bitmapShouldUseLargePages);
ProcessBuilder pb;
// Test with large page enabled. // Test with large page enabled.
pb = ProcessTools.createLimitedTestJavaProcessBuilder(getOpts(heapsize, true)); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(getOpts(heapsize, true));
OutputAnalyzer output = new OutputAnalyzer(pb.start());
// Only expect large page size if large pages are enabled. // Only expect large page size if large pages are enabled.
if (largePagesEnabled(output)) { if (largePagesEnabled(output)) {
@ -138,9 +135,8 @@ public class TestLargePageUseForAuxMemory {
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
// Test with large page disabled. // 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); checkSmallTables(output, smallPageSize);
checkBitmap(output, smallPageSize); checkBitmap(output, smallPageSize);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

27
test/hotspot/jtreg/gc/g1/TestLargePageUseForHeap.java
View File

@ -85,29 +85,26 @@ public class TestLargePageUseForHeap {
} }
static void testVM(long regionSize) throws Exception { static void testVM(long regionSize) throws Exception {
ProcessBuilder pb;
// Test with large page enabled. // Test with large page enabled.
pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-XX:G1HeapRegionSize=" + regionSize, "-XX:G1HeapRegionSize=" + regionSize,
"-Xmx128m", "-Xmx128m",
"-Xlog:gc+init,pagesize,gc+heap+coops=debug", "-Xlog:gc+init,pagesize,gc+heap+coops=debug",
"-XX:+UseLargePages", "-XX:+UseLargePages",
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
boolean largePageEnabled = checkLargePageEnabled(output); boolean largePageEnabled = checkLargePageEnabled(output);
checkHeap(output, largePageEnabled ? largePageSize : smallPageSize); checkHeap(output, largePageEnabled ? largePageSize : smallPageSize);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
// Test with large page disabled. // Test with large page disabled.
pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-XX:G1HeapRegionSize=" + regionSize, "-XX:G1HeapRegionSize=" + regionSize,
"-Xmx128m", "-Xmx128m",
"-Xlog:gc+init,pagesize,gc+heap+coops=debug", "-Xlog:gc+init,pagesize,gc+heap+coops=debug",
"-XX:-UseLargePages", "-XX:-UseLargePages",
"-version"); "-version");
output = new OutputAnalyzer(pb.start());
checkHeap(output, smallPageSize); checkHeap(output, smallPageSize);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }

4
test/hotspot/jtreg/gc/g1/TestMarkStackSizes.java
View File

@ -50,9 +50,7 @@ public class TestMarkStackSizes {
Collections.addAll(testArguments, extraArgs); Collections.addAll(testArguments, extraArgs);
testArguments.add("-version"); testArguments.add("-version");
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(testArguments); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(testArguments);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStderr()); System.out.println(output.getStderr());

4
test/hotspot/jtreg/gc/g1/TestMixedGCLiveThreshold.java
View File

@ -109,9 +109,7 @@ public class TestMixedGCLiveThreshold {
basicOpts.add(GCTest.class.getName()); basicOpts.add(GCTest.class.getName());
ProcessBuilder procBuilder = ProcessTools.createLimitedTestJavaProcessBuilder(basicOpts); return ProcessTools.executeLimitedTestJava(basicOpts);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
return analyzer;
} }
private static boolean regionsSelectedForRebuild(String output) throws Exception { private static boolean regionsSelectedForRebuild(String output) throws Exception {

3
test/hotspot/jtreg/gc/g1/TestOneEdenRegionAfterGC.java
View File

@ -40,7 +40,7 @@ public class TestOneEdenRegionAfterGC {
private static long YoungGenSize = 32 * 1024 * 1024; private static long YoungGenSize = 32 * 1024 * 1024;
private static OutputAnalyzer run() throws Exception { private static OutputAnalyzer run() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( return ProcessTools.executeLimitedTestJava(
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-Xmn" + YoungGenSize, "-Xmn" + YoungGenSize,
"-Xmx512M", "-Xmx512M",
@ -50,7 +50,6 @@ public class TestOneEdenRegionAfterGC {
"-Xlog:gc,gc+ergo*=trace", "-Xlog:gc,gc+ergo*=trace",
TestOneEdenRegionAfterGC.Allocate.class.getName(), TestOneEdenRegionAfterGC.Allocate.class.getName(),
"" + YoungGenSize); "" + YoungGenSize);
return new OutputAnalyzer(pb.start());
} }
public static void main(String args[]) throws Exception { public static void main(String args[]) throws Exception {

3
test/hotspot/jtreg/gc/g1/TestPLABOutput.java
View File

@ -59,8 +59,7 @@ public class TestPLABOutput {
GCTest.class.getName() GCTest.class.getName()
}; };
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(arguments); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(arguments);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

3
test/hotspot/jtreg/gc/g1/TestPLABSizeBounds.java
View File

@ -62,8 +62,7 @@ public class TestPLABSizeBounds {
testArguments.add("-XX:OldPLABSize=" + plabSize); testArguments.add("-XX:OldPLABSize=" + plabSize);
testArguments.add(GCTest.class.getName()); testArguments.add(GCTest.class.getName());
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(testArguments); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(testArguments);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
if (shouldSucceed) { if (shouldSucceed) {
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

22
test/hotspot/jtreg/gc/g1/TestPeriodicLogMessages.java
View File

@ -40,24 +40,22 @@ import jdk.test.lib.process.ProcessTools;
public class TestPeriodicLogMessages { public class TestPeriodicLogMessages {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-XX:G1PeriodicGCInterval=0", "-XX:G1PeriodicGCInterval=0",
"-Xlog:gc+init,gc+periodic=debug", "-Xlog:gc+init,gc+periodic=debug",
"-Xmx10M", "-Xmx10M",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Periodic GC: Disabled"); output.shouldContain("Periodic GC: Disabled");
output.shouldNotContain("Checking for periodic GC"); output.shouldNotContain("Checking for periodic GC");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-XX:G1PeriodicGCInterval=100", "-XX:G1PeriodicGCInterval=100",
"-Xlog:gc+init,gc+periodic=debug", "-Xlog:gc+init,gc+periodic=debug",
"-Xmx10M", "-Xmx10M",
GCTest.class.getName()); GCTest.class.getName());
output = new OutputAnalyzer(pb.start());
output.shouldContain("Periodic GC: Enabled"); output.shouldContain("Periodic GC: Enabled");
output.shouldContain("Periodic GC Interval: 100ms"); output.shouldContain("Periodic GC Interval: 100ms");
output.shouldContain("Checking for periodic GC"); output.shouldContain("Checking for periodic GC");

3
test/hotspot/jtreg/gc/g1/TestPrintRegionRememberedSetInfo.java
View File

@ -69,8 +69,7 @@ public class TestPrintRegionRememberedSetInfo {
finalargs.add(RunAndWaitForMarking.class.getName()); finalargs.add(RunAndWaitForMarking.class.getName());
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(finalargs); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(finalargs);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
String result = output.getStdout(); String result = output.getStdout();

14
test/hotspot/jtreg/gc/g1/TestRemsetLoggingThreads.java
View File

@ -44,14 +44,12 @@ import jdk.test.lib.process.ProcessTools;
public class TestRemsetLoggingThreads { public class TestRemsetLoggingThreads {
private static void runTest(int refinementThreads, int workerThreads) throws Exception { private static void runTest(int refinementThreads, int workerThreads) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-Xlog:gc+remset+exit=trace", "-Xlog:gc+remset+exit=trace",
"-XX:G1ConcRefinementThreads=" + refinementThreads, "-XX:G1ConcRefinementThreads=" + refinementThreads,
"-XX:ParallelGCThreads=" + workerThreads, "-XX:ParallelGCThreads=" + workerThreads,
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
String pattern = "Concurrent refinement threads times \\(s\\)$"; String pattern = "Concurrent refinement threads times \\(s\\)$";
Matcher m = Pattern.compile(pattern, Pattern.MULTILINE).matcher(output.getStdout()); Matcher m = Pattern.compile(pattern, Pattern.MULTILINE).matcher(output.getStdout());

3
test/hotspot/jtreg/gc/g1/TestRemsetLoggingTools.java
View File

@ -77,8 +77,7 @@ public class TestRemsetLoggingTools {
finalargs.add(VerifySummaryOutput.class.getName()); finalargs.add(VerifySummaryOutput.class.getName());
finalargs.add(String.valueOf(numGCs)); finalargs.add(String.valueOf(numGCs));
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(finalargs); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(finalargs);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

9
test/hotspot/jtreg/gc/g1/TestSharedArchiveWithPreTouch.java
View File

@ -50,8 +50,6 @@ public class TestSharedArchiveWithPreTouch {
final List<String> BaseOptions = Arrays.asList(new String[] {"-XX:+UseG1GC", "-XX:+AlwaysPreTouch", final List<String> BaseOptions = Arrays.asList(new String[] {"-XX:+UseG1GC", "-XX:+AlwaysPreTouch",
"-XX:+UnlockDiagnosticVMOptions", "-XX:SharedArchiveFile=" + ArchiveFileName }); "-XX:+UnlockDiagnosticVMOptions", "-XX:SharedArchiveFile=" + ArchiveFileName });
ProcessBuilder pb;
List<String> dump_args = new ArrayList<String>(BaseOptions); List<String> dump_args = new ArrayList<String>(BaseOptions);
if (Platform.is64bit()) { if (Platform.is64bit()) {
@ -59,8 +57,8 @@ public class TestSharedArchiveWithPreTouch {
} }
dump_args.addAll(Arrays.asList(new String[] { "-Xshare:dump", "-Xlog:cds" })); dump_args.addAll(Arrays.asList(new String[] { "-Xshare:dump", "-Xlog:cds" }));
pb = ProcessTools.createLimitedTestJavaProcessBuilder(dump_args); OutputAnalyzer output = ProcessTools.executeLimitedTestJava(dump_args);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
try { try {
output.shouldContain("Loading classes to share"); output.shouldContain("Loading classes to share");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
@ -72,8 +70,7 @@ public class TestSharedArchiveWithPreTouch {
} }
load_args.addAll(Arrays.asList(new String[] { "-Xshare:on", "-version" })); load_args.addAll(Arrays.asList(new String[] { "-Xshare:on", "-version" }));
pb = ProcessTools.createLimitedTestJavaProcessBuilder(load_args.toArray(new String[0])); output = ProcessTools.executeLimitedTestJava(load_args.toArray(new String[0]));
output = new OutputAnalyzer(pb.start());
output.shouldContain("sharing"); output.shouldContain("sharing");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} catch (RuntimeException e) { } catch (RuntimeException e) {

3
test/hotspot/jtreg/gc/g1/TestShrinkAuxiliaryData.java
View File

@ -88,9 +88,8 @@ public class TestShrinkAuxiliaryData {
} }
private void performTest(List<String> opts) throws Exception { 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.out.println(output.getStdout());
System.err.println(output.getStderr()); System.err.println(output.getStderr());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

3
test/hotspot/jtreg/gc/g1/TestShrinkDefragmentedHeap.java
View File

@ -61,7 +61,7 @@ public class TestShrinkDefragmentedHeap {
private static final int REGION_SIZE = 1 * 1024 * 1024; private static final int REGION_SIZE = 1 * 1024 * 1024;
public static void main(String[] args) throws Exception, Throwable { public static void main(String[] args) throws Exception, Throwable {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-XX:InitialHeapSize=" + INITIAL_HEAP_SIZE, "-XX:InitialHeapSize=" + INITIAL_HEAP_SIZE,
"-Xmn" + MINIMAL_YOUNG_SIZE, "-Xmn" + MINIMAL_YOUNG_SIZE,
"-Xmx" + MAXIMUM_HEAP_SIZE, "-Xmx" + MAXIMUM_HEAP_SIZE,
@ -74,7 +74,6 @@ public class TestShrinkDefragmentedHeap {
GCTest.class.getName() GCTest.class.getName()
); );
OutputAnalyzer output = ProcessTools.executeProcess(pb);
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }

21
test/hotspot/jtreg/gc/g1/TestSkipRebuildRemsetPhase.java
View File

@ -40,17 +40,16 @@ import jdk.test.whitebox.WhiteBox;
public class TestSkipRebuildRemsetPhase { public class TestSkipRebuildRemsetPhase {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-Xbootclasspath/a:.", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xbootclasspath/a:.",
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI", "-XX:+WhiteBoxAPI",
"-XX:G1MixedGCLiveThresholdPercent=20", "-XX:G1MixedGCLiveThresholdPercent=20",
"-Xlog:gc+marking=debug,gc+phases=debug,gc+remset+tracking=trace", "-Xlog:gc+marking=debug,gc+phases=debug,gc+remset+tracking=trace",
"-Xms10M", "-Xms10M",
"-Xmx10M", "-Xmx10M",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Skipping Remembered Set Rebuild."); output.shouldContain("Skipping Remembered Set Rebuild.");
output.shouldContain("No Remembered Sets to update after rebuild"); output.shouldContain("No Remembered Sets to update after rebuild");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

5
test/hotspot/jtreg/gc/g1/TestVerifyGCType.java
View File

@ -178,10 +178,7 @@ public class TestVerifyGCType {
basicOpts.add(TriggerGCs.class.getName()); basicOpts.add(TriggerGCs.class.getName());
ProcessBuilder procBuilder = ProcessTools.createLimitedTestJavaProcessBuilder(basicOpts); return ProcessTools.executeLimitedTestJava(basicOpts);
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
return analyzer;
} }
private static void verifyCollection(String name, boolean expectBefore, boolean expectDuring, boolean expectAfter, String data) { private static void verifyCollection(String name, boolean expectBefore, boolean expectDuring, boolean expectAfter, String data) {

4
test/hotspot/jtreg/gc/g1/humongousObjects/ClassLoaderGenerator.java
View File

@ -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 * Since the generation depends on current host architecture it cannot be done as part of pre-compilation step
*/ */
public class ClassLoaderGenerator { public class ClassLoaderGenerator {
public static void main(String[] args) throws IOException { public static void main(String[] args) throws Exception {
if (args.length != 1) { if (args.length != 1) {
throw new Error("Test Bug: Expected region size wasn't provided as command line argument"); 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 // Generating simple classloader
String finalSimpleClassLoaderPrototype = TestHumongousClassLoader.GENERIC_PROTOTYPE String finalSimpleClassLoaderPrototype = TestHumongousClassLoader.GENERIC_PROTOTYPE
.replace("${Methods}", .replace("${Methods}",

5
test/hotspot/jtreg/gc/g1/humongousObjects/G1SampleClass.java
View File

@ -75,12 +75,11 @@ public enum G1SampleClass {
* @param wrkDir working dir where generated classes are put and compiled * @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) * @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 * @return a class with instances of the specified size loaded in specified class loader
* @throws IOException * @throws Exception
* @throws ClassNotFoundException
*/ */
public Class<?> getCls(ClassLoader classLoader, Path wrkDir, String classNamePrefix) public Class<?> getCls(ClassLoader classLoader, Path wrkDir, String classNamePrefix)
throws IOException, ClassNotFoundException { throws Exception {
return Helpers.generateCompileAndLoad(classLoader, Helpers.enumNameToClassName(name()) + "Class", return Helpers.generateCompileAndLoad(classLoader, Helpers.enumNameToClassName(name()) + "Class",
expectedInstanceSize(), wrkDir, classNamePrefix); expectedInstanceSize(), wrkDir, classNamePrefix);
} }

4
test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousClassLoader.java
View File

@ -140,9 +140,7 @@ public class TestHumongousClassLoader {
public abstract void provoke(); public abstract void provoke();
} }
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, public static void main(String[] args) throws Exception {
IllegalAccessException, IOException, NoSuchMethodException, InvocationTargetException {
if (args.length != 1) { if (args.length != 1) {
throw new Error("Test Bug: Expected GC type wasn't provided as command line argument"); throw new Error("Test Bug: Expected GC type wasn't provided as command line argument");
} }

3
test/hotspot/jtreg/gc/g1/humongousObjects/TestHumongousNonArrayAllocation.java
View File

@ -82,8 +82,7 @@ public class TestHumongousNonArrayAllocation {
private static final WhiteBox WB = WhiteBox.getWhiteBox(); private static final WhiteBox WB = WhiteBox.getWhiteBox();
private static final String CLASS_NAME_PREFIX = TestHumongousNonArrayAllocation.class.getSimpleName() + "_"; private static final String CLASS_NAME_PREFIX = TestHumongousNonArrayAllocation.class.getSimpleName() + "_";
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, public static void main(String[] args) throws Exception {
IllegalAccessException, IOException {
if (args.length != 1) { if (args.length != 1) {
throw new Error("Test Bug: Expected class name wasn't provided as command line argument"); throw new Error("Test Bug: Expected class name wasn't provided as command line argument");

3
test/hotspot/jtreg/gc/g1/mixedgc/TestLogging.java
View File

@ -90,8 +90,7 @@ public class TestLogging {
Collections.addAll(testOpts, extraFlags); Collections.addAll(testOpts, extraFlags);
testOpts.add(RunMixedGC.class.getName()); testOpts.add(RunMixedGC.class.getName());
System.out.println(testOpts); System.out.println(testOpts);
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(testOpts); return ProcessTools.executeLimitedTestJava(testOpts);
return new OutputAnalyzer(pb.start());
} }
} }

3
test/hotspot/jtreg/gc/g1/numa/TestG1NUMATouchRegions.java
View File

@ -181,7 +181,7 @@ public class TestG1NUMATouchRegions {
return; return;
} }
ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer output = ProcessTools.executeLimitedTestJava(
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-Xlog:pagesize,gc+heap+region=trace", "-Xlog:pagesize,gc+heap+region=trace",
"-XX:+UseG1GC", "-XX:+UseG1GC",
@ -195,7 +195,6 @@ public class TestG1NUMATouchRegions {
largePagesSetting, largePagesSetting,
"-XX:G1HeapRegionSize=" + regionSizeInMB + "m", "-XX:G1HeapRegionSize=" + regionSizeInMB + "m",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb_enabled.start());
// Check NUMA availability. // Check NUMA availability.
if (status == NUMASupportStatus.NOT_CHECKED) { if (status == NUMASupportStatus.NOT_CHECKED) {

22
test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectTypes.java
View File

@ -48,18 +48,17 @@ public class TestPinnedObjectTypes {
} }
private static void testPinning(String type, boolean shouldSucceed) throws Exception { private static void testPinning(String type, boolean shouldSucceed) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI", "-XX:+WhiteBoxAPI",
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-XX:-CreateCoredumpOnCrash", "-XX:-CreateCoredumpOnCrash",
"-Xmx32M", "-Xmx32M",
"-Xmn16M", "-Xmn16M",
"-Xlog:gc", "-Xlog:gc",
TestObjectPin.class.getName(), TestObjectPin.class.getName(),
type); type);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStdout()); System.out.println(output.getStdout());
if (shouldSucceed) { if (shouldSucceed) {
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
@ -84,4 +83,3 @@ class TestObjectPin {
wb.pinObject(o); wb.pinObject(o);
} }
} }

24
test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedObjectsEvacuation.java
View File

@ -64,19 +64,18 @@ public class TestPinnedObjectsEvacuation {
} }
private static void testPinnedEvacuation(int younGCsBeforeUnpin, int expectedSkipEvents, int expectedDropEvents, int expectedReclaimEvents) throws Exception { private static void testPinnedEvacuation(int younGCsBeforeUnpin, int expectedSkipEvents, int expectedDropEvents, int expectedReclaimEvents) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI", "-XX:+WhiteBoxAPI",
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-Xmx32M", "-Xmx32M",
"-Xmn16M", "-Xmn16M",
"-XX:G1NumCollectionsKeepPinned=2", "-XX:G1NumCollectionsKeepPinned=2",
"-XX:+VerifyAfterGC", "-XX:+VerifyAfterGC",
"-Xlog:gc,gc+ergo+cset=trace", "-Xlog:gc,gc+ergo+cset=trace",
TestObjectPin.class.getName(), TestObjectPin.class.getName(),
String.valueOf(younGCsBeforeUnpin)); String.valueOf(younGCsBeforeUnpin));
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStdout()); System.out.println(output.getStdout());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
@ -128,4 +127,3 @@ class TestObjectPin {
wb.youngGC(); wb.youngGC();
} }
} }

34
test/hotspot/jtreg/gc/g1/pinnedobjs/TestPinnedOldObjectsEvacuation.java
View File

@ -257,24 +257,23 @@ public class TestPinnedOldObjectsEvacuation {
int expectedDropEvents, int expectedDropEvents,
int expectedMarkingReclaimEvents, int expectedMarkingReclaimEvents,
int expectedRetainedReclaimEvents) throws Exception { int expectedRetainedReclaimEvents) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UseG1GC", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+UseG1GC",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI", "-XX:+WhiteBoxAPI",
"-Xbootclasspath/a:.", "-Xbootclasspath/a:.",
"-Xmx32M", "-Xmx32M",
"-Xmn16M", "-Xmn16M",
"-XX:MarkSweepDeadRatio=0", "-XX:MarkSweepDeadRatio=0",
"-XX:G1NumCollectionsKeepPinned=3", "-XX:G1NumCollectionsKeepPinned=3",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
// Take all old regions to make sure that the pinned one is included in the collection set. // Take all old regions to make sure that the pinned one is included in the collection set.
"-XX:G1MixedGCLiveThresholdPercent=100", "-XX:G1MixedGCLiveThresholdPercent=100",
"-XX:G1HeapWastePercent=0", "-XX:G1HeapWastePercent=0",
"-XX:+VerifyAfterGC", "-XX:+VerifyAfterGC",
"-Xlog:gc,gc+ergo+cset=trace", "-Xlog:gc,gc+ergo+cset=trace",
TestObjectPin.class.getName(), TestObjectPin.class.getName(),
String.valueOf(youngGCsBeforeUnpin)); String.valueOf(youngGCsBeforeUnpin));
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStdout()); System.out.println(output.getStdout());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
@ -334,4 +333,3 @@ class TestObjectPin {
wb.youngGC(); wb.youngGC();
} }
} }

12
test/hotspot/jtreg/gc/logging/TestDeprecatedPrintFlags.java
View File

@ -42,8 +42,7 @@ import java.util.stream.Collectors;
public class TestDeprecatedPrintFlags { public class TestDeprecatedPrintFlags {
public static void testPrintGC() throws Exception { public static void testPrintGC() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+PrintGC", DoGC.class.getName()); OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+PrintGC", DoGC.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("-XX:+PrintGC is deprecated. Will use -Xlog:gc instead."); output.shouldContain("-XX:+PrintGC is deprecated. Will use -Xlog:gc instead.");
output.shouldNotContain("PrintGCDetails"); output.shouldNotContain("PrintGCDetails");
output.stdoutShouldMatch("\\[info.*\\]\\[gc *\\]"); output.stdoutShouldMatch("\\[info.*\\]\\[gc *\\]");
@ -52,8 +51,7 @@ public class TestDeprecatedPrintFlags {
} }
public static void testPrintGCDetails() throws Exception { public static void testPrintGCDetails() throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+PrintGCDetails", DoGC.class.getName()); OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+PrintGCDetails", DoGC.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("-XX:+PrintGCDetails is deprecated. Will use -Xlog:gc* instead."); output.shouldContain("-XX:+PrintGCDetails is deprecated. Will use -Xlog:gc* instead.");
output.shouldNotContain("PrintGC is deprecated"); output.shouldNotContain("PrintGC is deprecated");
output.stdoutShouldMatch("\\[info.*\\]\\[gc *\\]"); output.stdoutShouldMatch("\\[info.*\\]\\[gc *\\]");
@ -63,8 +61,7 @@ public class TestDeprecatedPrintFlags {
public static void testXloggc() throws Exception { public static void testXloggc() throws Exception {
String fileName = "gc-test.log"; String fileName = "gc-test.log";
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-Xloggc:" + fileName, DoGC.class.getName()); OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xloggc:" + fileName, DoGC.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("-Xloggc is deprecated. Will use -Xlog:gc:gc-test.log instead."); output.shouldContain("-Xloggc is deprecated. Will use -Xlog:gc:gc-test.log instead.");
output.shouldNotContain("PrintGCDetails"); output.shouldNotContain("PrintGCDetails");
output.shouldNotContain("PrintGC"); output.shouldNotContain("PrintGC");
@ -80,8 +77,7 @@ public class TestDeprecatedPrintFlags {
public static void testXloggcWithPrintGCDetails() throws Exception { public static void testXloggcWithPrintGCDetails() throws Exception {
String fileName = "gc-test.log"; String fileName = "gc-test.log";
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+PrintGCDetails", "-Xloggc:" + fileName, DoGC.class.getName()); OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-XX:+PrintGCDetails", "-Xloggc:" + fileName, DoGC.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("-XX:+PrintGCDetails is deprecated. Will use -Xlog:gc* instead."); 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.shouldContain("-Xloggc is deprecated. Will use -Xlog:gc:gc-test.log instead.");
output.shouldNotContain("PrintGC is deprecated"); output.shouldNotContain("PrintGC is deprecated");

6
test/hotspot/jtreg/gc/logging/TestGCId.java
View File

@ -73,9 +73,9 @@ public class TestGCId {
} }
private static void testGCId(String gcFlag) throws Exception { private static void testGCId(String gcFlag) throws Exception {
ProcessBuilder pb_default = OutputAnalyzer output =
ProcessTools.createLimitedTestJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions", "-XX:+" + gcFlag, "-Xlog:gc", "-Xmx10M", GCTest.class.getName()); ProcessTools.executeLimitedTestJava("-XX:+UnlockExperimentalVMOptions", "-XX:+" + gcFlag, "-Xlog:gc", "-Xmx10M", GCTest.class.getName());
verifyContainsGCIDs(new OutputAnalyzer(pb_default.start())); verifyContainsGCIDs(output);
} }
static class GCTest { static class GCTest {

24
test/hotspot/jtreg/gc/logging/TestMetaSpaceLog.java
View File

@ -93,24 +93,24 @@ public class TestMetaSpaceLog {
} }
private static void testMetaSpaceUpdate() throws Exception { 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; OutputAnalyzer output = null;
try { try {
output = new OutputAnalyzer(pb.start()); output = ProcessTools.executeTestJava(
"-Xlog:gc*",
"-Xbootclasspath/a:.",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI",
"-Xmx1000M",
"-Xms1000M",
StressMetaSpace.class.getName());
verifyContainsMetaSpaceUpdate(output); verifyContainsMetaSpaceUpdate(output);
} catch (Exception e) { } catch (Exception e) {
// For error diagnosis: print and throw. // For error diagnosis: print and throw.
e.printStackTrace(); e.printStackTrace();
output.reportDiagnosticSummary(); if (output != null) {
output.reportDiagnosticSummary();
}
throw e; throw e;
} }
} }

24
test/hotspot/jtreg/gc/logging/TestPrintReferences.java
View File

@ -67,11 +67,10 @@ public class TestPrintReferences {
} }
public static void testRefs() throws Exception { public static void testRefs() throws Exception {
ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder("-Xlog:gc+ref+phases=debug", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xlog:gc+ref+phases=debug",
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-Xmx32M", "-Xmx32M",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb_enabled.start());
checkRefsLogFormat(output); checkRefsLogFormat(output);
@ -95,14 +94,13 @@ public class TestPrintReferences {
} }
public static void testPhases(boolean parallelRefProcEnabled) throws Exception { public static void testPhases(boolean parallelRefProcEnabled) throws Exception {
ProcessBuilder pb_enabled = ProcessTools.createLimitedTestJavaProcessBuilder("-Xlog:gc+phases+ref=debug", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xlog:gc+phases+ref=debug",
"-XX:+UseG1GC", "-XX:+UseG1GC",
"-Xmx32M", "-Xmx32M",
"-XX:" + (parallelRefProcEnabled ? "+" : "-") + "ParallelRefProcEnabled", "-XX:" + (parallelRefProcEnabled ? "+" : "-") + "ParallelRefProcEnabled",
"-XX:-UseDynamicNumberOfGCThreads", "-XX:-UseDynamicNumberOfGCThreads",
"-XX:ParallelGCThreads=2", "-XX:ParallelGCThreads=2",
GCTest.class.getName()); GCTest.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb_enabled.start());
checkLogFormat(output, parallelRefProcEnabled); checkLogFormat(output, parallelRefProcEnabled);
checkLogValue(output); checkLogValue(output);

5
test/hotspot/jtreg/gc/metaspace/CompressedClassSpaceSizeInJmapHeap.java
View File

@ -77,9 +77,8 @@ public class CompressedClassSpaceSizeInJmapHeap {
} }
private static void run(ProcessBuilder pb) throws Exception { private static void run(ProcessBuilder pb) throws Exception {
Process p = pb.start(); OutputAnalyzer output = ProcessTools.executeProcess(pb);
p.waitFor(); int exitValue = output.getExitValue();
int exitValue = p.exitValue();
if (exitValue != 0) { if (exitValue != 0) {
throw new Exception("jmap -heap exited with error code: " + exitValue); throw new Exception("jmap -heap exited with error code: " + exitValue);
} }

3
test/hotspot/jtreg/gc/metaspace/TestMetaspaceSizeFlags.java
View File

@ -84,13 +84,12 @@ public class TestMetaspaceSizeFlags {
} }
private static OutputAnalyzer run(long maxMetaspaceSize, long metaspaceSize) throws Exception { private static OutputAnalyzer run(long maxMetaspaceSize, long metaspaceSize) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( return ProcessTools.executeLimitedTestJava(
"-XX:MaxMetaspaceSize=" + maxMetaspaceSize, "-XX:MaxMetaspaceSize=" + maxMetaspaceSize,
"-XX:MetaspaceSize=" + metaspaceSize, "-XX:MetaspaceSize=" + metaspaceSize,
"-XX:-UseLargePages", // Prevent us from using 2GB large pages on solaris + sparc. "-XX:-UseLargePages", // Prevent us from using 2GB large pages on solaris + sparc.
"-XX:+PrintFlagsFinal", "-XX:+PrintFlagsFinal",
"-version"); "-version");
return new OutputAnalyzer(pb.start());
} }
private static class MetaspaceFlags { private static class MetaspaceFlags {

3
test/hotspot/jtreg/gc/metaspace/TestSizeTransitions.java
View File

@ -119,8 +119,7 @@ public class TestSizeTransitions {
System.out.println(" " + a); System.out.println(" " + a);
} }
final ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(jvmArgs); final OutputAnalyzer output = ProcessTools.executeLimitedTestJava(jvmArgs);
final OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println(output.getStdout()); System.out.println(output.getStdout());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);

3
test/hotspot/jtreg/gc/serial/HeapChangeLogging.java
View File

@ -41,8 +41,7 @@ import jdk.test.lib.process.OutputAnalyzer;
public class HeapChangeLogging { public class HeapChangeLogging {
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-Xmx128m", "-Xmn100m", "-XX:+UseSerialGC", "-Xlog:gc", HeapFiller.class.getName()); OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xmx128m", "-Xmn100m", "-XX:+UseSerialGC", "-Xlog:gc", HeapFiller.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
String stdout = output.getStdout(); String stdout = output.getStdout();
System.out.println(stdout); System.out.println(stdout);
Matcher stdoutMatcher = Pattern.compile(".*\\(Allocation Failure\\) [0-9]+[KMG]->[0-9]+[KMG]\\([0-9]+[KMG]\\)", Pattern.MULTILINE).matcher(stdout); Matcher stdoutMatcher = Pattern.compile(".*\\(Allocation Failure\\) [0-9]+[KMG]->[0-9]+[KMG]\\([0-9]+[KMG]\\)", Pattern.MULTILINE).matcher(stdout);

3
test/hotspot/jtreg/gc/shenandoah/TestEvilSyncBug.java
View File

@ -56,14 +56,13 @@ public class TestEvilSyncBug {
for (int c = 0; c < NUM_RUNS; c++) { for (int c = 0; c < NUM_RUNS; c++) {
Callable<Void> task = () -> { Callable<Void> task = () -> {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder("-Xms128m", OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xms128m",
"-Xmx128m", "-Xmx128m",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UnlockDiagnosticVMOptions", "-XX:+UnlockDiagnosticVMOptions",
"-XX:+UseShenandoahGC", "-XX:+UseShenandoahGC",
"-XX:ShenandoahGCHeuristics=aggressive", "-XX:ShenandoahGCHeuristics=aggressive",
"TestEvilSyncBug", "test"); "TestEvilSyncBug", "test");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
return null; return null;
}; };

7
test/hotspot/jtreg/gc/shenandoah/TestJcmdHeapDump.java
View File

@ -127,6 +127,7 @@
*/ */
import jdk.test.lib.JDKToolLauncher; import jdk.test.lib.JDKToolLauncher;
import jdk.test.lib.process.ProcessTools;
import jdk.test.lib.process.OutputAnalyzer; import jdk.test.lib.process.OutputAnalyzer;
import java.io.File; import java.io.File;
@ -141,11 +142,7 @@ public class TestJcmdHeapDump {
jcmd.addToolArg(dumpFileName); jcmd.addToolArg(dumpFileName);
try { try {
ProcessBuilder pb = new ProcessBuilder(jcmd.getCommand()); OutputAnalyzer output = ProcessTools.executeProcess(jcmd.getCommand());
Process jcmdProc = pb.start();
OutputAnalyzer output = new OutputAnalyzer(jcmdProc);
jcmdProc.waitFor();
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} catch (Exception e) { } catch (Exception e) {
throw new RuntimeException("Test failed: " + e); throw new RuntimeException("Test failed: " + e);

3
test/hotspot/jtreg/gc/shenandoah/TestObjItrWithHeapDump.java
View File

@ -41,9 +41,8 @@ public class TestObjItrWithHeapDump {
String[] cmds = Arrays.copyOf(args, args.length + 2); String[] cmds = Arrays.copyOf(args, args.length + 2);
cmds[args.length] = TestObjItrWithHeapDump.class.getName(); cmds[args.length] = TestObjItrWithHeapDump.class.getName();
cmds[args.length + 1] = "test"; 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.shouldHaveExitValue(0);
output.shouldContain("Class Histogram (before full gc)"); output.shouldContain("Class Histogram (before full gc)");
output.shouldContain("Class Histogram (after full gc)"); output.shouldContain("Class Histogram (after full gc)");

3
test/hotspot/jtreg/gc/shenandoah/TestPeriodicGC.java
View File

@ -42,9 +42,8 @@ public class TestPeriodicGC {
String[] cmds = Arrays.copyOf(args, args.length + 2); String[] cmds = Arrays.copyOf(args, args.length + 2);
cmds[args.length] = TestPeriodicGC.class.getName(); cmds[args.length] = TestPeriodicGC.class.getName();
cmds[args.length + 1] = "test"; 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.shouldHaveExitValue(0);
if (periodic && !output.getOutput().contains("Trigger: Time since last GC")) { if (periodic && !output.getOutput().contains("Trigger: Time since last GC")) {
throw new AssertionError(msg + ": Should have periodic GC in logs"); throw new AssertionError(msg + ": Should have periodic GC in logs");

6
test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargeObj.java
View File

@ -55,27 +55,25 @@ public class TestAllocLargeObj {
} }
{ {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
"-Xmx16m", "-Xmx16m",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UseShenandoahGC", "-XX:+UseShenandoahGC",
TestAllocLargeObj.class.getName(), TestAllocLargeObj.class.getName(),
"test"); "test");
OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
analyzer.shouldHaveExitValue(1); analyzer.shouldHaveExitValue(1);
analyzer.shouldContain("java.lang.OutOfMemoryError: Java heap space"); analyzer.shouldContain("java.lang.OutOfMemoryError: Java heap space");
} }
{ {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
"-Xmx1g", "-Xmx1g",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UseShenandoahGC", "-XX:+UseShenandoahGC",
TestAllocLargeObj.class.getName(), TestAllocLargeObj.class.getName(),
"test"); "test");
OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);
analyzer.shouldNotContain("java.lang.OutOfMemoryError: Java heap space"); analyzer.shouldNotContain("java.lang.OutOfMemoryError: Java heap space");
} }

6
test/hotspot/jtreg/gc/shenandoah/oom/TestAllocLargerThanHeap.java
View File

@ -50,27 +50,25 @@ public class TestAllocLargerThanHeap {
} }
{ {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
"-Xmx16m", "-Xmx16m",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UseShenandoahGC", "-XX:+UseShenandoahGC",
TestAllocLargerThanHeap.class.getName(), TestAllocLargerThanHeap.class.getName(),
"test"); "test");
OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
analyzer.shouldHaveExitValue(1); analyzer.shouldHaveExitValue(1);
analyzer.shouldContain("java.lang.OutOfMemoryError: Java heap space"); analyzer.shouldContain("java.lang.OutOfMemoryError: Java heap space");
} }
{ {
ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( OutputAnalyzer analyzer = ProcessTools.executeLimitedTestJava(
"-Xmx1g", "-Xmx1g",
"-XX:+UnlockExperimentalVMOptions", "-XX:+UnlockExperimentalVMOptions",
"-XX:+UseShenandoahGC", "-XX:+UseShenandoahGC",
TestAllocLargerThanHeap.class.getName(), TestAllocLargerThanHeap.class.getName(),
"test"); "test");
OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
analyzer.shouldHaveExitValue(0); analyzer.shouldHaveExitValue(0);
analyzer.shouldNotContain("java.lang.OutOfMemoryError: Java heap space"); analyzer.shouldNotContain("java.lang.OutOfMemoryError: Java heap space");
} }

Some files were not shown because too many files have changed in this diff Show More