test/java/lang/ProcessBuilder/Basic.java

rev 13659 : 8208715: Conversion of milliseconds to nanoseconds in UNIXProcess contains bug

*** 1,7 ****
  /*
!  * Copyright (c) 2003, 2013, 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.
--- 1,7 ----
  /*
!  * Copyright (c) 2003, 2019, 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.
*** 59,68 ****
--- 59,77 ----
      static final String cfUserTextEncoding = System.getenv("__CF_USER_TEXT_ENCODING");
  
      /* used for AIX only */
      static final String libpath = System.getenv("LIBPATH");
  
+     /**
+      * Returns the number of milliseconds since time given by
+      * startNanoTime, which must have been previously returned from a
+      * call to {@link System.nanoTime()}.
+      */
+     private static long millisElapsedSince(long startNanoTime) {
+         return TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
+     }
+ 
      private static String commandOutput(Reader r) throws Throwable {
          StringBuilder sb = new StringBuilder();
          int c;
          while ((c = r.read()) > 0)
              if (c != '\r')
*** 2292,2335 ****
                  + ", exitValue: " + exitValue);
          } catch (Throwable t) { unexpected(t); }
  
          //----------------------------------------------------------------
          // Check that Process.waitFor(timeout, TimeUnit.MILLISECONDS)
!         // interrupt works as expected.
          //----------------------------------------------------------------
          try {
              List<String> childArgs = new ArrayList<String>(javaChildArgs);
              childArgs.add("sleep");
              final Process p = new ProcessBuilder(childArgs).start();
              final long start = System.nanoTime();
!             final CountDownLatch ready = new CountDownLatch(1);
!             final CountDownLatch done = new CountDownLatch(1);
  
              final Thread thread = new Thread() {
                  public void run() {
                      try {
!                         final boolean result;
!                         try {
!                             ready.countDown();
!                             result = p.waitFor(30000, TimeUnit.MILLISECONDS);
!                         } catch (InterruptedException e) {
!                             return;
!                         }
                          fail("waitFor() wasn't interrupted, its return value was: " + result);
!                     } catch (Throwable t) {
!                         unexpected(t);
!                     } finally {
!                         done.countDown();
                      }
                  }
              };
  
              thread.start();
!             ready.await();
!             Thread.sleep(1000);
              thread.interrupt();
!             done.await();
              p.destroy();
          } catch (Throwable t) { unexpected(t); }
  
          //----------------------------------------------------------------
          // Check the default implementation for
--- 2301,2369 ----
                  + ", exitValue: " + exitValue);
          } catch (Throwable t) { unexpected(t); }
  
          //----------------------------------------------------------------
          // Check that Process.waitFor(timeout, TimeUnit.MILLISECONDS)
!         // interrupt works as expected, if interrupted while waiting.
          //----------------------------------------------------------------
          try {
              List<String> childArgs = new ArrayList<String>(javaChildArgs);
              childArgs.add("sleep");
              final Process p = new ProcessBuilder(childArgs).start();
              final long start = System.nanoTime();
!             final CountDownLatch aboutToWaitFor = new CountDownLatch(1);
  
              final Thread thread = new Thread() {
                  public void run() {
                      try {
!                         aboutToWaitFor.countDown();
!                         Thread.currentThread().interrupt();
!                         boolean result = p.waitFor(30L * 1000L, TimeUnit.MILLISECONDS);
                          fail("waitFor() wasn't interrupted, its return value was: " + result);
!                     } catch (InterruptedException success) {
!                     } catch (Throwable t) { unexpected(t); }
                  }
+             };
+ 
+             thread.start();
+             aboutToWaitFor.await();
+             thread.interrupt();
+             thread.join(10L * 1000L);
+             check(millisElapsedSince(start) < 10L * 1000L);
+             check(!thread.isAlive());
+             p.destroy();
+         } catch (Throwable t) { unexpected(t); }
+ 
+         //----------------------------------------------------------------
+         // Check that Process.waitFor(Long.MAX_VALUE, TimeUnit.MILLISECONDS)
+         // interrupt works as expected, if interrupted while waiting.
+         //----------------------------------------------------------------
+         try {
+             List<String> childArgs = new ArrayList<String>(javaChildArgs);
+             childArgs.add("sleep");
+             final Process p = new ProcessBuilder(childArgs).start();
+             final long start = System.nanoTime();
+             final CountDownLatch aboutToWaitFor = new CountDownLatch(1);
+ 
+             final Thread thread = new Thread() {
+                 public void run() {
+                     try {
+                         aboutToWaitFor.countDown();
+                         Thread.currentThread().interrupt();
+                         boolean result = p.waitFor(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
+                         fail("waitFor() wasn't interrupted, its return value was: " + result);
+                     } catch (InterruptedException success) {
+                     } catch (Throwable t) { unexpected(t); }
                  }
              };
  
              thread.start();
!             aboutToWaitFor.await();
              thread.interrupt();
!             thread.join(10L * 1000L);
!             check(millisElapsedSince(start) < 10L * 1000L);
!             check(!thread.isAlive());
              p.destroy();
          } catch (Throwable t) { unexpected(t); }
  
          //----------------------------------------------------------------
          // Check the default implementation for