test/jdk/java/lang/ProcessHandle/TreeTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */


 import java.io.IOException;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

 import jdk.test.lib.Utils;
 import org.testng.Assert;
 import org.testng.TestNG;
 import org.testng.annotations.Test;

 /*
  * @test
  * @library /test/lib
  * @modules java.base/jdk.internal.misc
  *          jdk.management
  * @build jdk.test.lib.Utils
  *        jdk.test.lib.Asserts
  *        jdk.test.lib.JDKToolFinder
  *        jdk.test.lib.JDKToolLauncher
  *        jdk.test.lib.Platform
  *        jdk.test.lib.process.*
  * @run testng/othervm TreeTest
  * @summary Test counting and JavaChild.spawning and counting of Processes.
  * @author Roger Riggs
  */
 public class TreeTest extends ProcessUtil {
     // Main can be used to run the tests from the command line with only testng.jar.
     @SuppressWarnings("raw_types")
     public static void main(String[] args) {
         Class<?>[] testclass = {TreeTest.class};
         TestNG testng = new TestNG();
         testng.setTestClasses(testclass);
         testng.run();
     }

     /**
      * Test counting and spawning and counting of Processes.
      */
     @Test
     public static void test1() {
         final int MAXCHILDREN = 2;
         List<JavaChild> spawned = new ArrayList<>();

         try {
             ProcessHandle self = ProcessHandle.current();

             printf("self pid: %d%n", self.pid());
             printDeep(self, "");

             for (int i = 0; i < MAXCHILDREN; i++) {
                 // spawn and wait for instructions
                 spawned.add(JavaChild.spawnJavaChild("pid", "stdin"));
             }

             // Verify spawned Process is in list of children
             final List<ProcessHandle> initialChildren = getChildren(self);
             spawned.stream()
                     .map(Process::toHandle)
                     .filter(p -> !initialChildren.contains(p))
                     .forEach(p -> Assert.fail("Spawned process missing from children: " + p));

             // Send exit command to each spawned Process
             spawned.forEach(p -> {
                     try {
                         p.sendAction("exit", "");
                     } catch (IOException ex) {
                         Assert.fail("IOException in sendAction", ex);
                     }
                 });

             // Wait for each Process to exit
             spawned.forEach(p -> {
                     do {
                         try {
                             Assert.assertEquals(p.waitFor(), 0, "exit status incorrect");
                             break;
                         } catch (InterruptedException  ex) {
                             continue; // Retry
                         }
                     } while (true);
                 });

             // Verify that ProcessHandle.isAlive sees each of them as not alive
             for (Process p : spawned) {
                 ProcessHandle ph = p.toHandle();
                 Assert.assertFalse(ph.isAlive(),
                         "ProcessHandle.isAlive for exited process: " + ph);
             }

             // Verify spawned processes are not visible as children
             final List<ProcessHandle> afterChildren = getChildren(self);
             spawned.stream()
                     .map(Process::toHandle)
                     .filter(p -> afterChildren.contains(p))
                     .forEach(p -> Assert.fail("Spawned process missing from children: " + p));

         } catch (IOException ioe) {
             Assert.fail("unable to spawn process", ioe);
         } finally {
             // Cleanup any left over processes
             spawned.stream()
                     .map(Process::toHandle)
                     .filter(ProcessHandle::isAlive)
                     .forEach(ph -> {
                         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: "));
             }

             JavaChild p1 = JavaChild.spawnJavaChild("stdin");
             ProcessHandle p1Handle = p1.toHandle();
             printf("  p1 pid: %d%n", p1.pid());

             // 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
             List<ProcessHandle> subprocesses = waitForAllChildren(p1Handle, spawnNew);
             Optional<Instant> p1Start = p1Handle.info().startInstant();
             for (ProcessHandle ph : subprocesses) {
                 Assert.assertTrue(ph.isAlive(), "Child should be alive: " + ph);
                 // Verify each child was started after the parent
                 ph.info().startInstant()
                         .ifPresent(childStart -> p1Start.ifPresent(parentStart -> {
                             Assert.assertFalse(childStart.isBefore(parentStart),
                                     String.format("Child process started before parent: child: %s, parent: %s",
                                             childStart, parentStart));
                         }));
             }

             // Each child spawns two processes and waits for commands
             int spawnNewSub = 2;
             p1.sendAction("child", "spawn", spawnNewSub, "stdin");

             // Poll until all 9 child processes exist or the timeout is reached
             int expected = 9;
             long timeout = Utils.adjustTimeout(60L);
             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> descendants = getDescendants(p1Handle);
             printf(" descendants:  %s%n",
                     descendants.stream().map(p -> p.pid())
                            .collect(Collectors.toList()));

             // Verify that all spawned children show up in the descendants  List
             processes.forEach((p, parent) -> {
                 Assert.assertEquals(p.isAlive(), true, "Child should be alive: " + p);
                 Assert.assertTrue(descendants.contains(p), "Spawned child should be listed in descendants: " + p);
             });

             // Closing JavaChild's InputStream will cause all children to exit
             p1.getOutputStream().close();

             for (ProcessHandle p : descendants) {
                 try {
                     p.onExit().get();       // wait for the child to exit
                 } catch (ExecutionException e) {
                     Assert.fail("waiting for process to exit", e);
                 }
             }
             p1.waitFor();           // wait for spawned process to exit

             // Verify spawned processes are no longer alive
             processes.forEach((ph, parent) -> Assert.assertFalse(ph.isAlive(),
                             "process should not be alive: " + ph));
         } catch (IOException | InterruptedException t) {
             t.printStackTrace();
             throw new RuntimeException(t);
         }
     }

     /**
      * Test destroy of processes.
      * A JavaChild is started and it starts three children.
      * Each one is then checked to be alive and listed by descendants
      * and forcibly destroyed.
      * After they exit they should no longer be listed by descendants.
      */
     @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.pid());

             int newChildren = 3;
             CountDownLatch spawnCount = new CountDownLatch(newChildren);
             // Spawn children and have them wait
             p1.sendAction("spawn", newChildren, "stdin");

             // Gather the PIDs from the output of the spawning 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());
                     spawnCount.countDown();
                 }
             });

             // Wait for all the subprocesses to be listed as started
             Assert.assertTrue(spawnCount.await(Utils.adjustTimeout(30L), TimeUnit.SECONDS),
                     "Timeout waiting for processes to start");

             // Debugging; list descendants that are not expected in processes
             List<ProcessHandle> descendants = ProcessUtil.getDescendants(p1Handle);
             long count = descendants.stream()
                     .filter(ph -> !processes.containsKey(ph))
                     .count();
             if (count > 0) {
                 descendants.stream()
                     .filter(ph -> !processes.containsKey(ph))
                     .forEach(ph1 -> ProcessUtil.printProcess(ph1, "Extra process: "));
                 ProcessUtil.logTaskList();
                 Assert.assertEquals(0, count, "Extra processes in descendants");
             }

             // Verify that all spawned children are alive, show up in the descendants list
             // then destroy them
             processes.forEach((p, parent) -> {
                 Assert.assertEquals(p.isAlive(), true, "Child should be alive: " + p);
                 Assert.assertTrue(descendants.contains(p), "Spawned child should be listed in descendants: " + p);
                 p.destroyForcibly();
             });
             Assert.assertEquals(processes.size(), newChildren, "Wrong number of children");

             // Wait for each of the processes to exit
             processes.forEach((p, parent) ->  {
                 for (long retries = Utils.adjustTimeout(100L); retries > 0 ; retries--) {
                     if (!p.isAlive()) {
                         return;                 // not alive, go on to the next
                     }
                     // Wait a bit and retry
                     try {
                         Thread.sleep(100L);
                     } catch (InterruptedException ie) {
                         // try again
                     }
                 }
                 printf("Timeout waiting for exit of pid %s, parent: %s, info: %s%n",
                         p, parent, p.info());
                 Assert.fail("Process still alive: " + p);
             });
             p1.destroyForcibly();
             p1.waitFor();

             // Verify that none of the spawned children are still listed by descendants
             List<ProcessHandle> remaining = getDescendants(self);
             Assert.assertFalse(remaining.remove(p1Handle), "Child p1 should have exited");
             remaining = remaining.stream().filter(processes::containsKey).collect(Collectors.toList());
             Assert.assertEquals(remaining.size(), 0, "Subprocess(es) should have exited: " + remaining);

         } catch (IOException ioe) {
             Assert.fail("Spawn of subprocess failed", ioe);
         } catch (InterruptedException inte) {
             Assert.fail("InterruptedException", inte);
         } finally {
             processes.forEach((p, parent) -> {
                 if (p.isAlive()) {
                     ProcessUtil.printProcess(p);
                     p.destroyForcibly();
                 }
             });
         }
     }

     /**
      * Test (Not really a test) that dumps the list of all Processes.
      */
     @Test
     public static void test4() {
         printf("    Parent     Child  Info%n");
         Stream<ProcessHandle> s = ProcessHandle.allProcesses();
         ProcessHandle[] processes = s.toArray(ProcessHandle[]::new);
         int len = processes.length;
         ProcessHandle[] parent = new ProcessHandle[len];
         Set<ProcessHandle> processesSet =
                 Arrays.stream(processes).collect(Collectors.toSet());
         Integer[] sortindex = new Integer[len];
         for (int i = 0; i < len; i++) {
             sortindex[i] = i;
          }
         for (int i = 0; i < len; i++) {
             parent[sortindex[i]] = processes[sortindex[i]].parent().orElse(null);
         }
         Arrays.sort(sortindex, (i1, i2) -> {
             int cmp = Long.compare((parent[i1] == null ? 0L : parent[i1].pid()),
                     (parent[i2] == null ? 0L : parent[i2].pid()));
             if (cmp == 0) {
                 cmp = Long.compare((processes[i1] == null ? 0L : processes[i1].pid()),
                         (processes[i2] == null ? 0L : processes[i2].pid()));
             }
             return cmp;
         });
         boolean fail = false;
         for (int i = 0; i < len; i++) {
             ProcessHandle p = processes[sortindex[i]];
             ProcessHandle p_parent = parent[sortindex[i]];
             ProcessHandle.Info info = p.info();
             String indent = "    ";
             if (p_parent != null) {
                 if (!processesSet.contains(p_parent)) {
                     fail = true;
                     indent = "*** ";
                 }
             }
             printf("%s %7s, %7s, %s%n", indent, p_parent, p, info);
         }
         Assert.assertFalse(fail, "Parents missing from all Processes");

     }

     /**
      * A test for scale; launch a large number (14) of subprocesses.
      */
     @Test
     public static void test5() {
         ConcurrentHashMap<ProcessHandle, ProcessHandle> processes = new ConcurrentHashMap<>();

         int factor = 2;
         JavaChild p1 = null;
         Instant start = Instant.now();
         try {
             p1 = JavaChild.spawnJavaChild("stdin");
             ProcessHandle p1Handle = p1.toHandle();

             printf("Spawning %d x %d x %d processes, pid: %d%n",
                     factor, factor, factor, p1.pid());

             // Start the first tier of subprocesses
             p1.sendAction("spawn", factor, "stdin");

             // Start the second tier of subprocesses
             p1.sendAction("child", "spawn", factor, "stdin");

             // Start the third tier of subprocesses
             p1.sendAction("child", "child", "spawn", factor, "stdin");

             int newChildren = factor * (1 + factor * (1 + factor));
             CountDownLatch spawnCount = new CountDownLatch(newChildren);

             // Gather the PIDs from the output of the spawning 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());
                     spawnCount.countDown();
                 }
             });

             // Wait for all the subprocesses to be listed as started
             Assert.assertTrue(spawnCount.await(Utils.adjustTimeout(30L), TimeUnit.SECONDS),
                     "Timeout waiting for processes to start");

             // Debugging; list descendants that are not expected in processes
             List<ProcessHandle> descendants = ProcessUtil.getDescendants(p1Handle);
             long count = descendants.stream()
                     .filter(ph -> !processes.containsKey(ph))
                     .count();
             if (count > 0) {
                 descendants.stream()
                     .filter(ph -> !processes.containsKey(ph))
                     .forEach(ph1 -> ProcessUtil.printProcess(ph1, "Extra process: "));
                 ProcessUtil.logTaskList();
                 Assert.assertEquals(0, count, "Extra processes in descendants");
             }

             Assert.assertEquals(getChildren(p1Handle).size(),
                     factor, "expected direct children");
             count = getDescendants(p1Handle).size();
             long totalChildren = factor * factor * factor + factor * factor + factor;
             Assert.assertTrue(count >= totalChildren,
                     "expected at least " + totalChildren + ", actual: " + count);

             List<ProcessHandle> subprocesses = getDescendants(p1Handle);
             printf(" descendants:  %s%n",
                     subprocesses.stream().map(p -> p.pid())
                     .collect(Collectors.toList()));

             p1.getOutputStream().close();  // Close stdin for the controlling p1
             p1.waitFor();
         } catch (InterruptedException | IOException ex) {
             Assert.fail("Unexpected Exception", ex);
         } finally {
             printf("Duration: %s%n", Duration.between(start, Instant.now()));
             if (p1 != null) {
                 p1.destroyForcibly();
             }
             processes.forEach((p, parent) -> {
                 if (p.isAlive()) {
                     ProcessUtil.printProcess(p, "Process Cleanup: ");
                     p.destroyForcibly();
                 }
             });
         }
     }

 }
	/*
	* Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/


	import java.io.IOException;
	import java.time.Duration;
	import java.time.Instant;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;
	import java.util.Optional;
	import java.util.Set;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.TimeUnit;
	import java.util.stream.Collectors;
	import java.util.stream.Stream;

	import jdk.test.lib.Utils;
	import org.testng.Assert;
	import org.testng.TestNG;
	import org.testng.annotations.Test;

	/*
	* @test
	* @library /test/lib
	* @modules java.base/jdk.internal.misc
	* jdk.management
	* @build jdk.test.lib.Utils
	* jdk.test.lib.Asserts
	* jdk.test.lib.JDKToolFinder
	* jdk.test.lib.JDKToolLauncher
	* jdk.test.lib.Platform
	* jdk.test.lib.process.*
	* @run testng/othervm TreeTest
	* @summary Test counting and JavaChild.spawning and counting of Processes.
	* @author Roger Riggs
	*/
	public class TreeTest extends ProcessUtil {
	// Main can be used to run the tests from the command line with only testng.jar.
	@SuppressWarnings("raw_types")
	public static void main(String[] args) {
	Class<?>[] testclass = {TreeTest.class};
	TestNG testng = new TestNG();
	testng.setTestClasses(testclass);
	testng.run();
	}

	/**
	* Test counting and spawning and counting of Processes.
	*/
	@Test
	public static void test1() {
	final int MAXCHILDREN = 2;
	List<JavaChild> spawned = new ArrayList<>();

	try {
	ProcessHandle self = ProcessHandle.current();

	printf("self pid: %d%n", self.pid());
	printDeep(self, "");

	for (int i = 0; i < MAXCHILDREN; i++) {
	// spawn and wait for instructions
	spawned.add(JavaChild.spawnJavaChild("pid", "stdin"));
	}

	// Verify spawned Process is in list of children
	final List<ProcessHandle> initialChildren = getChildren(self);
	spawned.stream()
	.map(Process::toHandle)
	.filter(p -> !initialChildren.contains(p))
	.forEach(p -> Assert.fail("Spawned process missing from children: " + p));

	// Send exit command to each spawned Process
	spawned.forEach(p -> {
	try {
	p.sendAction("exit", "");
	} catch (IOException ex) {
	Assert.fail("IOException in sendAction", ex);
	}
	});

	// Wait for each Process to exit
	spawned.forEach(p -> {
	do {
	try {
	Assert.assertEquals(p.waitFor(), 0, "exit status incorrect");
	break;
	} catch (InterruptedException ex) {
	continue; // Retry
	}
	} while (true);
	});

	// Verify that ProcessHandle.isAlive sees each of them as not alive
	for (Process p : spawned) {
	ProcessHandle ph = p.toHandle();
	Assert.assertFalse(ph.isAlive(),
	"ProcessHandle.isAlive for exited process: " + ph);
	}

	// Verify spawned processes are not visible as children
	final List<ProcessHandle> afterChildren = getChildren(self);
	spawned.stream()
	.map(Process::toHandle)
	.filter(p -> afterChildren.contains(p))
	.forEach(p -> Assert.fail("Spawned process missing from children: " + p));

	} catch (IOException ioe) {
	Assert.fail("unable to spawn process", ioe);
	} finally {
	// Cleanup any left over processes
	spawned.stream()
	.map(Process::toHandle)
	.filter(ProcessHandle::isAlive)
	.forEach(ph -> {
	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: "));
	}

	JavaChild p1 = JavaChild.spawnJavaChild("stdin");
	ProcessHandle p1Handle = p1.toHandle();
	printf(" p1 pid: %d%n", p1.pid());

	// 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
	List<ProcessHandle> subprocesses = waitForAllChildren(p1Handle, spawnNew);
	Optional<Instant> p1Start = p1Handle.info().startInstant();
	for (ProcessHandle ph : subprocesses) {
	Assert.assertTrue(ph.isAlive(), "Child should be alive: " + ph);
	// Verify each child was started after the parent
	ph.info().startInstant()
	.ifPresent(childStart -> p1Start.ifPresent(parentStart -> {
	Assert.assertFalse(childStart.isBefore(parentStart),
	String.format("Child process started before parent: child: %s, parent: %s",
	childStart, parentStart));
	}));
	}

	// Each child spawns two processes and waits for commands
	int spawnNewSub = 2;
	p1.sendAction("child", "spawn", spawnNewSub, "stdin");

	// Poll until all 9 child processes exist or the timeout is reached
	int expected = 9;
	long timeout = Utils.adjustTimeout(60L);
	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> descendants = getDescendants(p1Handle);
	printf(" descendants: %s%n",
	descendants.stream().map(p -> p.pid())
	.collect(Collectors.toList()));

	// Verify that all spawned children show up in the descendants List
	processes.forEach((p, parent) -> {
	Assert.assertEquals(p.isAlive(), true, "Child should be alive: " + p);
	Assert.assertTrue(descendants.contains(p), "Spawned child should be listed in descendants: " + p);
	});

	// Closing JavaChild's InputStream will cause all children to exit
	p1.getOutputStream().close();

	for (ProcessHandle p : descendants) {
	try {
	p.onExit().get(); // wait for the child to exit
	} catch (ExecutionException e) {
	Assert.fail("waiting for process to exit", e);
	}
	}
	p1.waitFor(); // wait for spawned process to exit

	// Verify spawned processes are no longer alive
	processes.forEach((ph, parent) -> Assert.assertFalse(ph.isAlive(),
	"process should not be alive: " + ph));
	} catch (IOException \| InterruptedException t) {
	t.printStackTrace();
	throw new RuntimeException(t);
	}
	}

	/**
	* Test destroy of processes.
	* A JavaChild is started and it starts three children.
	* Each one is then checked to be alive and listed by descendants
	* and forcibly destroyed.
	* After they exit they should no longer be listed by descendants.
	*/
	@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.pid());

	int newChildren = 3;
	CountDownLatch spawnCount = new CountDownLatch(newChildren);
	// Spawn children and have them wait
	p1.sendAction("spawn", newChildren, "stdin");

	// Gather the PIDs from the output of the spawning 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());
	spawnCount.countDown();
	}
	});

	// Wait for all the subprocesses to be listed as started
	Assert.assertTrue(spawnCount.await(Utils.adjustTimeout(30L), TimeUnit.SECONDS),
	"Timeout waiting for processes to start");

	// Debugging; list descendants that are not expected in processes
	List<ProcessHandle> descendants = ProcessUtil.getDescendants(p1Handle);
	long count = descendants.stream()
	.filter(ph -> !processes.containsKey(ph))
	.count();
	if (count > 0) {
	descendants.stream()
	.filter(ph -> !processes.containsKey(ph))
	.forEach(ph1 -> ProcessUtil.printProcess(ph1, "Extra process: "));
	ProcessUtil.logTaskList();
	Assert.assertEquals(0, count, "Extra processes in descendants");
	}

	// Verify that all spawned children are alive, show up in the descendants list
	// then destroy them
	processes.forEach((p, parent) -> {
	Assert.assertEquals(p.isAlive(), true, "Child should be alive: " + p);
	Assert.assertTrue(descendants.contains(p), "Spawned child should be listed in descendants: " + p);
	p.destroyForcibly();
	});
	Assert.assertEquals(processes.size(), newChildren, "Wrong number of children");

	// Wait for each of the processes to exit
	processes.forEach((p, parent) -> {
	for (long retries = Utils.adjustTimeout(100L); retries > 0 ; retries--) {
	if (!p.isAlive()) {
	return; // not alive, go on to the next
	}
	// Wait a bit and retry
	try {
	Thread.sleep(100L);
	} catch (InterruptedException ie) {
	// try again
	}
	}
	printf("Timeout waiting for exit of pid %s, parent: %s, info: %s%n",
	p, parent, p.info());
	Assert.fail("Process still alive: " + p);
	});
	p1.destroyForcibly();
	p1.waitFor();

	// Verify that none of the spawned children are still listed by descendants
	List<ProcessHandle> remaining = getDescendants(self);
	Assert.assertFalse(remaining.remove(p1Handle), "Child p1 should have exited");
	remaining = remaining.stream().filter(processes::containsKey).collect(Collectors.toList());
	Assert.assertEquals(remaining.size(), 0, "Subprocess(es) should have exited: " + remaining);

	} catch (IOException ioe) {
	Assert.fail("Spawn of subprocess failed", ioe);
	} catch (InterruptedException inte) {
	Assert.fail("InterruptedException", inte);
	} finally {
	processes.forEach((p, parent) -> {
	if (p.isAlive()) {
	ProcessUtil.printProcess(p);
	p.destroyForcibly();
	}
	});
	}
	}

	/**
	* Test (Not really a test) that dumps the list of all Processes.
	*/
	@Test
	public static void test4() {
	printf(" Parent Child Info%n");
	Stream<ProcessHandle> s = ProcessHandle.allProcesses();
	ProcessHandle[] processes = s.toArray(ProcessHandle[]::new);
	int len = processes.length;
	ProcessHandle[] parent = new ProcessHandle[len];
	Set<ProcessHandle> processesSet =
	Arrays.stream(processes).collect(Collectors.toSet());
	Integer[] sortindex = new Integer[len];
	for (int i = 0; i < len; i++) {
	sortindex[i] = i;
	}
	for (int i = 0; i < len; i++) {
	parent[sortindex[i]] = processes[sortindex[i]].parent().orElse(null);
	}
	Arrays.sort(sortindex, (i1, i2) -> {
	int cmp = Long.compare((parent[i1] == null ? 0L : parent[i1].pid()),
	(parent[i2] == null ? 0L : parent[i2].pid()));
	if (cmp == 0) {
	cmp = Long.compare((processes[i1] == null ? 0L : processes[i1].pid()),
	(processes[i2] == null ? 0L : processes[i2].pid()));
	}
	return cmp;
	});
	boolean fail = false;
	for (int i = 0; i < len; i++) {
	ProcessHandle p = processes[sortindex[i]];
	ProcessHandle p_parent = parent[sortindex[i]];
	ProcessHandle.Info info = p.info();
	String indent = " ";
	if (p_parent != null) {
	if (!processesSet.contains(p_parent)) {
	fail = true;
	indent = "*** ";
	}
	}
	printf("%s %7s, %7s, %s%n", indent, p_parent, p, info);
	}
	Assert.assertFalse(fail, "Parents missing from all Processes");

	}

	/**
	* A test for scale; launch a large number (14) of subprocesses.
	*/
	@Test
	public static void test5() {
	ConcurrentHashMap<ProcessHandle, ProcessHandle> processes = new ConcurrentHashMap<>();

	int factor = 2;
	JavaChild p1 = null;
	Instant start = Instant.now();
	try {
	p1 = JavaChild.spawnJavaChild("stdin");
	ProcessHandle p1Handle = p1.toHandle();

	printf("Spawning %d x %d x %d processes, pid: %d%n",
	factor, factor, factor, p1.pid());

	// Start the first tier of subprocesses
	p1.sendAction("spawn", factor, "stdin");

	// Start the second tier of subprocesses
	p1.sendAction("child", "spawn", factor, "stdin");

	// Start the third tier of subprocesses
	p1.sendAction("child", "child", "spawn", factor, "stdin");

	int newChildren = factor * (1 + factor * (1 + factor));
	CountDownLatch spawnCount = new CountDownLatch(newChildren);

	// Gather the PIDs from the output of the spawning 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());
	spawnCount.countDown();
	}
	});

	// Wait for all the subprocesses to be listed as started
	Assert.assertTrue(spawnCount.await(Utils.adjustTimeout(30L), TimeUnit.SECONDS),
	"Timeout waiting for processes to start");

	// Debugging; list descendants that are not expected in processes
	List<ProcessHandle> descendants = ProcessUtil.getDescendants(p1Handle);
	long count = descendants.stream()
	.filter(ph -> !processes.containsKey(ph))
	.count();
	if (count > 0) {
	descendants.stream()
	.filter(ph -> !processes.containsKey(ph))
	.forEach(ph1 -> ProcessUtil.printProcess(ph1, "Extra process: "));
	ProcessUtil.logTaskList();
	Assert.assertEquals(0, count, "Extra processes in descendants");
	}

	Assert.assertEquals(getChildren(p1Handle).size(),
	factor, "expected direct children");
	count = getDescendants(p1Handle).size();
	long totalChildren = factor * factor * factor + factor * factor + factor;
	Assert.assertTrue(count >= totalChildren,
	"expected at least " + totalChildren + ", actual: " + count);

	List<ProcessHandle> subprocesses = getDescendants(p1Handle);
	printf(" descendants: %s%n",
	subprocesses.stream().map(p -> p.pid())
	.collect(Collectors.toList()));

	p1.getOutputStream().close(); // Close stdin for the controlling p1
	p1.waitFor();
	} catch (InterruptedException \| IOException ex) {
	Assert.fail("Unexpected Exception", ex);
	} finally {
	printf("Duration: %s%n", Duration.between(start, Instant.now()));
	if (p1 != null) {
	p1.destroyForcibly();
	}
	processes.forEach((p, parent) -> {
	if (p.isAlive()) {
	ProcessUtil.printProcess(p, "Process Cleanup: ");
	p.destroyForcibly();
	}
	});
	}
	}

	}