--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/java/lang/ProcessHandle/OnExitTest.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,311 @@
+/*
+ * 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.List;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+
+import jdk.test.lib.Utils;
+
+import org.testng.annotations.Test;
+import org.testng.Assert;
+import org.testng.TestNG;
+
+/*
+ * @test
+ * @key intermittent
+ * @library /test/lib
+ * @build jdk.test.lib.Utils
+ * @run testng OnExitTest
+ * @summary Functions of Process.onExit and ProcessHandle.onExit
+ * @author Roger Riggs
+ */
+
+public class OnExitTest extends ProcessUtil {
+
+ @SuppressWarnings("raw_types")
+ public static void main(String[] args) {
+ Class<?>[] testclass = { OnExitTest.class};
+ TestNG testng = new TestNG();
+ testng.setTestClasses(testclass);
+ testng.run();
+ }
+
+ /**
+ * Basic test of exitValue and onExit.
+ */
+ @Test
+ public static void test1() {
+ try {
+ int[] exitValues = {0, 1, 10};
+ for (int value : exitValues) {
+ Process p = JavaChild.spawn("exit", Integer.toString(value));
+ CompletableFuture<Process> future = p.onExit();
+ future.thenAccept( (ph) -> {
+ int actualExitValue = ph.exitValue();
+ printf(" javaChild done: %s, exitStatus: %d%n",
+ ph, actualExitValue);
+ Assert.assertEquals(actualExitValue, value, "actualExitValue incorrect");
+ Assert.assertEquals(ph, p, "Different Process passed to thenAccept");
+ });
+
+ Process h = future.get();
+ Assert.assertEquals(h, p);
+ Assert.assertEquals(p.exitValue(), value);
+ Assert.assertFalse(p.isAlive(), "Process should not be alive");
+ p.waitFor();
+ }
+ } catch (IOException | InterruptedException | ExecutionException ex) {
+ Assert.fail(ex.getMessage(), ex);
+ } finally {
+ destroyProcessTree(ProcessHandle.current());
+ }
+ }
+
+ /**
+ * Test of Completion handler when parent is killed.
+ * Spawn 1 child to spawn 3 children each with 2 children.
+ */
+ @Test
+ public static void test2() {
+ ProcessHandle procHandle = null;
+ try {
+ ConcurrentHashMap<ProcessHandle, ProcessHandle> processes = new ConcurrentHashMap<>();
+ List<ProcessHandle> children = getChildren(ProcessHandle.current());
+ children.forEach(ProcessUtil::printProcess);
+
+ JavaChild proc = JavaChild.spawnJavaChild("stdin");
+ procHandle = proc.toHandle();
+ printf(" spawned: %d%n", proc.pid());
+
+ proc.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());
+ }
+ });
+
+ proc.sendAction("spawn", "3", "stdin");
+
+ proc.sendAction("child", "spawn", "2", "stdin");
+
+ // Poll until all 9 child processes exist or the timeout is reached
+ int expected = 9;
+ long timeout = 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");
+ }
+ children = getDescendants(procHandle);
+
+ ConcurrentHashMap<ProcessHandle, CompletableFuture<ProcessHandle>> completions =
+ new ConcurrentHashMap<>();
+ Instant startTime = Instant.now();
+ // Create a future for each of the 9 children
+ processes.forEach( (p, parent) -> {
+ CompletableFuture<ProcessHandle> cf = p.onExit().whenComplete((ph, ex) -> {
+ Duration elapsed = Duration.between(startTime, Instant.now());
+ printf("whenComplete: pid: %s, exception: %s, thread: %s, elapsed: %s%n",
+ ph, ex, Thread.currentThread(), elapsed);
+ });
+ completions.put(p, cf);
+ });
+
+ // Check that each of the spawned processes is included in the children
+ List<ProcessHandle> remaining = new ArrayList<>(children);
+ processes.forEach((p, parent) -> {
+ Assert.assertTrue(remaining.remove(p), "spawned process should have been in children");
+ });
+
+ // Remove Win32 system spawned conhost.exe processes
+ remaining.removeIf(ProcessUtil::isWindowsConsole);
+
+ remaining.forEach(p -> printProcess(p, "unexpected: "));
+ if (remaining.size() > 0) {
+ // Show full list for debugging
+ ProcessUtil.logTaskList();
+ }
+
+ proc.destroy(); // kill off the parent
+ proc.waitFor();
+
+ // Wait for all the processes and corresponding onExit CF to be completed
+ processes.forEach((p, parent) -> {
+ try {
+ p.onExit().get();
+ completions.get(p).join();
+ } catch (InterruptedException | ExecutionException ex) {
+ // ignore
+ }
+ });
+
+ // Verify that all 9 exit handlers were called with the correct ProcessHandle
+ processes.forEach((p, parent) -> {
+ ProcessHandle value = completions.get(p).getNow(null);
+ Assert.assertEquals(p, value, "onExit.get value expected: " + p
+ + ", actual: " + value
+ + ": " + p.info());
+ });
+
+ // Show the status of the original children
+ children.forEach(p -> printProcess(p, "after onExit:"));
+
+ Assert.assertEquals(proc.isAlive(), false, "destroyed process is alive:: %s%n" + proc);
+ } catch (IOException | InterruptedException ex) {
+ Assert.fail(ex.getMessage());
+ } finally {
+ if (procHandle != null) {
+ destroyProcessTree(procHandle);
+ }
+ }
+ }
+
+ /**
+ * Verify that onExit completes for a non-child process only when
+ * the process has exited.
+ * Spawn a child (A) waiting to be commanded to exit.
+ * Spawn a child (B) to wait for that process to exit.
+ * Command (A) to exit.
+ * Check that (B) does not complete until (A) has exited.
+ */
+ @Test
+ public static void peerOnExitTest() {
+ String line = null;
+ ArrayBlockingQueue<String> alines = new ArrayBlockingQueue<>(100);
+ ArrayBlockingQueue<String> blines = new ArrayBlockingQueue<>(100);
+ JavaChild A = null;
+ try {
+ String[] split;
+ A = JavaChild.spawnJavaChild("stdin");
+ A.forEachOutputLine(l -> alines.add(l));
+
+ // Verify A is running
+ A.sendAction("pid");
+ do {
+ split = getSplitLine(alines);
+ } while (!"pid".equals(split[1]));
+
+ JavaChild B = null;
+ try {
+ B = JavaChild.spawnJavaChild("stdin");
+ B.forEachOutputLine(l -> blines.add(l));
+
+ // Verify B is running
+ B.sendAction("pid");
+ do {
+ split = getSplitLine(blines);
+ } while (!"pid".equals(split[1]));
+
+ // Tell B to wait for A's pid
+ B.sendAction("waitpid", A.pid());
+
+ // Wait a bit to see if B will prematurely report the termination of A
+ try {
+ line = blines.poll(5L, TimeUnit.SECONDS);
+ } catch (InterruptedException ie) {
+ Assert.fail("interrupted", ie);
+ }
+ Assert.assertNull(line, "waitpid didn't wait");
+
+ A.toHandle().onExit().thenAccept(p -> {
+ System.out.printf(" A.toHandle().onExit().A info: %s, now: %s%n",
+ p.info(), Instant.now());
+ });
+
+ A.onExit().thenAccept(p -> {
+ System.out.printf(" A.onExit().A info: %s, now: %s%n",
+ p.info(), Instant.now());
+ });
+
+ ProcessHandle.Info A_info = A.info();
+
+ A.sendAction("exit", 0L);
+
+ // Look for B to report that A has exited
+ do {
+ Instant start = Instant.now();
+ while (blines.isEmpty() && A.isAlive()) {
+ A_info = A.info(); // Spin
+ }
+ Instant end = Instant.now();
+ System.out.printf(" a.isAlive: %s, a.info: %s, @%s%n", A.isAlive(), A.info(),
+ Duration.between(start, end));
+
+ split = getSplitLine(blines);
+ } while (!"waitpid".equals(split[1]));
+
+ Assert.assertEquals(split[2], "false", "Process A should not be alive");
+
+ B.sendAction("exit", 0L);
+ } catch (IOException ioe) {
+ Assert.fail("unable to start JavaChild B", ioe);
+ } finally {
+ B.destroyForcibly();
+ }
+ } catch (IOException ioe2) {
+ Assert.fail("unable to start JavaChild A", ioe2);
+ } finally {
+ A.destroyForcibly();
+ }
+ }
+
+ private static boolean DEBUG = true;
+
+ /**
+ * Get a line from the queue and split into words on whitespace.
+ * Log to stdout if requested.
+ * @param queue a queue of strings
+ * @return the words split from the line.
+ */
+ private static String[] getSplitLine(ArrayBlockingQueue<String> queue) {
+ try {
+ String line = queue.take();
+ String[] split = line.split("\\s");
+ if (DEBUG) {
+ System.out.printf(" Child Output: %s%n", line);
+ }
+ return split;
+ } catch (InterruptedException ie) {
+ Assert.fail("interrupted", ie);
+ return null;
+ }
+ }
+
+}