jdk-sandbox: comparison jdk/test/java/lang/ProcessHandle/TreeTest.java

equal deleted inserted replaced

-:52d938abd6ba
+:b5e9f5c24646
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.concurrent.ExecutionException;
 import org.testng.Assert;
 try {
 ProcessHandle self = ProcessHandle.current();
 printf("self pid: %d%n", self.getPid());
 printDeep(self, "");
-long count = getChildren(self).size();
-Assert.assertEquals(count, 0, "Start with zero children");
 for (int i = 0; i < MAXCHILDREN; i++) {
 // spawn and wait for instructions
 spawned.add(JavaChild.spawnJavaChild("pid", "stdin"));
 }
 } finally {
 // Cleanup any left over processes
 spawned.stream()
 .map(Process::toHandle)
 .filter(ProcessHandle::isAlive)
-.forEach(ph -> printDeep(ph, "test1 cleanup: "));
+.forEach(ph -> {
-destroyProcessTree(ProcessHandle.current());
+printDeep(ph, "test1 cleanup: ");
+ph.destroyForcibly();
+});
 }
 }
 /**
 * Test counting and spawning and counting of Processes.
 */
 @Test
 public static void test2() {
 try {
+ConcurrentHashMap<ProcessHandle, ProcessHandle> processes = new ConcurrentHashMap<>();
 ProcessHandle self = ProcessHandle.current();
 List<ProcessHandle> initialChildren = getChildren(self);
 long count = initialChildren.size();
 if (count > 0) {
 initialChildren.forEach(p -> printDeep(p, "test2 initial unexpected: "));
-Assert.assertEquals(count, 0, "Start with zero children (except Windows conhost.exe)");
 }
 JavaChild p1 = JavaChild.spawnJavaChild("stdin");
 ProcessHandle p1Handle = p1.toHandle();
 printf("  p1 pid: %d%n", p1.getPid());
+// Gather the PIDs from the output of the spawing process
+p1.forEachOutputLine((s) -> {
+String[] split = s.trim().split(" ");
+if (split.length == 3 && split[1].equals("spawn")) {
+Long child = Long.valueOf(split[2]);
+Long parent = Long.valueOf(split[0].split(":")[0]);
+processes.put(ProcessHandle.of(child).get(), ProcessHandle.of(parent).get());
+}
+});
 int spawnNew = 3;
 p1.sendAction("spawn", spawnNew, "stdin");
 // Wait for direct children to be created and save the list
 // Each child spawns two processes and waits for commands
 int spawnNewSub = 2;
 p1.sendAction("child", "spawn", spawnNewSub, "stdin");
-// For each spawned child, wait for its children
+// Poll until all 9 child processes exist or the timeout is reached
-for (ProcessHandle p : subprocesses) {
+int expected = 9;
-List<ProcessHandle> grandChildren = waitForChildren(p, spawnNewSub);
+long timeout = jdk.testlibrary.Utils.adjustTimeout(10L);
-}
+Instant endTimeout = Instant.now().plusSeconds(timeout);
+do {
+Thread.sleep(200L);
+printf(" subprocess count: %d, waiting for %d%n", processes.size(), expected);
+} while (processes.size() < expected &&
+Instant.now().isBefore(endTimeout));
+if (processes.size() < expected) {
+printf("WARNING: not all children have been started. Can't complete test.%n");
+printf("         You can try to increase the timeout or%n");
+printf("         you can try to use a faster VM (i.e. not a debug version).%n");
+}
+// show the complete list of children (for debug)
 List<ProcessHandle> allChildren = getAllChildren(p1Handle);
 printf(" allChildren:  %s%n",
 allChildren.stream().map(p -> p.getPid())
 .collect(Collectors.toList()));
-for (ProcessHandle ph : allChildren) {
-Assert.assertEquals(ph.isAlive(), true, "Child should be alive: " + ph);
+// Verify that all spawned children show up in the allChildrenList
-}
+processes.forEach((p, parent) -> {
+Assert.assertEquals(p.isAlive(), true, "Child should be alive: " + p);
+Assert.assertTrue(allChildren.contains(p), "Spawned child should be listed in allChildren: " + p);
+});
 // Closing JavaChild's InputStream will cause all children to exit
 p1.getOutputStream().close();
 for (ProcessHandle p : allChildren) {
 Assert.fail("waiting for process to exit", e);
 }
 }
 p1.waitFor();           // wait for spawned process to exit
-List<ProcessHandle> remaining = getChildren(self);
+// Verify spawned processes are no longer alive
-remaining.forEach(ph -> Assert.assertFalse(ph.isAlive(),
+processes.forEach((ph, parent) -> Assert.assertFalse(ph.isAlive(),
 "process should not be alive: " + ph));
 } catch (IOException | InterruptedException t) {
 t.printStackTrace();
 throw new RuntimeException(t);
-} finally {
-// Cleanup any left over processes
-destroyProcessTree(ProcessHandle.current());
 }
 }
 /**
 * Test destroy of processes.
 */
 @Test
 public static void test3() {
+ConcurrentHashMap<ProcessHandle, ProcessHandle> processes = new ConcurrentHashMap<>();
 try {
 ProcessHandle self = ProcessHandle.current();
 JavaChild p1 = JavaChild.spawnJavaChild("stdin");
 ProcessHandle p1Handle = p1.toHandle();
 printf(" p1: %s%n", p1.getPid());
-List<ProcessHandle> subprocesses = getChildren(self);
-long count = subprocesses.size();
-Assert.assertEquals(count, 1, "Wrong number of spawned children");
 int newChildren = 3;
 // Spawn children and have them wait
 p1.sendAction("spawn", newChildren, "stdin");
+// Gather the PIDs from the output of the spawing process
+p1.forEachOutputLine((s) -> {
+String[] split = s.trim().split(" ");
+if (split.length == 3 && split[1].equals("spawn")) {
+Long child = Long.valueOf(split[2]);
+Long parent = Long.valueOf(split[0].split(":")[0]);
+processes.put(ProcessHandle.of(child).get(), ProcessHandle.of(parent).get());
+}
+});
 // Wait for the new processes and save the list
-subprocesses = waitForAllChildren(p1Handle, newChildren);
+List<ProcessHandle> allChildren = waitForAllChildren(p1Handle, newChildren);
-Assert.assertEquals(subprocesses.size(), newChildren, "Wrong number of children");
+// Verify that all spawned children are alive, show up in the allChildren list
-p1.children().filter(TreeTest::isNotWindowsConsole)
+// then destroy them
-.forEach(ProcessHandle::destroyForcibly);
+processes.forEach((p, parent) -> {
+Assert.assertEquals(p.isAlive(), true, "Child should be alive: " + p);
-self.children().filter(TreeTest::isNotWindowsConsole)
+Assert.assertTrue(allChildren.contains(p), "Spawned child should be listed in allChildren: " + p);
-.forEach(ProcessHandle::destroyForcibly);
+p.destroyForcibly();
+});
-for (ProcessHandle p : subprocesses) {
+processes.forEach((p, parent) ->  {
 while (p.isAlive()) {
-Thread.sleep(100L);  // It will happen but don't burn the cpu
+try {
-}
+Thread.sleep(100L);  // It will happen but don't burn the cpu
-}
+} catch (InterruptedException ie) {
+// try again
+}
+}
+});
+p1.destroyForcibly();
+p1.waitFor();
 List<ProcessHandle> remaining = getAllChildren(self);
-remaining.retainAll(subprocesses);
+remaining = remaining.stream().filter(processes::contains).collect(Collectors.toList());
-if (remaining.size() > 0) {
+Assert.assertEquals(remaining.size(), 0, "Subprocess(es) should have exited: " + remaining);
-remaining.forEach(p -> printProcess(p, "     remaining: "));
-Assert.fail("Subprocess(es) should have exited");
-}
 } catch (IOException ioe) {
 Assert.fail("Spawn of subprocess failed", ioe);
 } catch (InterruptedException inte) {
 Assert.fail("InterruptedException", inte);
 } finally {
-// Cleanup any left over processes
+processes.forEach((p, parent) -> p.destroyForcibly());
-destroyProcessTree(ProcessHandle.current());
 }
 }
 /**
 * Test (Not really a test) that dumps the list of all Processes.
 * A test for scale; launch a large number (14) of subprocesses.
 */
 @Test
 public static void test5() {
 int factor = 2;
+JavaChild p1 = null;
 Instant start = Instant.now();
 try {
-JavaChild p1 = JavaChild.spawnJavaChild("stdin");
+p1 = JavaChild.spawnJavaChild("stdin");
 ProcessHandle p1Handle = p1.toHandle();
 printf("Spawning %d x %d x %d processes, pid: %d%n",
 factor, factor, factor, p1.getPid());
 p1.waitFor();
 } catch (InterruptedException | IOException ex) {
 Assert.fail("Unexpected Exception", ex);
 } finally {
 printf("Duration: %s%n", Duration.between(start, Instant.now()));
-destroyProcessTree(ProcessHandle.current());
+if (p1 != null) {
+p1.destroyForcibly();
+}
 }
 }
 }

changeset 32660	b5e9f5c24646
parent 31683	ac6d7a188995
child 32843	dc30a72ce1d9