thread1.callAndAssertReturns(waitFor(), guard);
  }

  public final void testWaitFor_initiallyFalse() throws Exception {
    TestGuard guard = new TestGuard(false);
    thread1.callAndAssertReturns(enter());
    thread1.callAndAssertWaits(waitFor(), guard);
    monitor.enter();
    guard.setSatisfied(true);
    monitor.leave();
    thread1.assertPriorCallReturns(waitFor());
  }

    thread1.callAndAssertReturns(waitFor(), guard);
  }

  public final void testWaitFor_initiallyFalse() throws Exception {
    TestGuard guard = new TestGuard(false);
    thread1.callAndAssertReturns(enter());
    thread1.callAndAssertWaits(waitFor(), guard);
    monitor.enter();
    guard.setSatisfied(true);
    monitor.leave();
    thread1.assertPriorCallReturns(waitFor());
  }

    <V> ClosingCallable<V> waitFor(ClosingCallable<V> closingCallable) {
      return waitFor(closingCallable, ClosingCallable.class);
    }

    @SuppressWarnings("unchecked") // proxy for a generic class
    <V> AsyncClosingCallable<V> waitFor(AsyncClosingCallable<V> asyncClosingCallable) {
      return waitFor(asyncClosingCallable, AsyncClosingCallable.class);
    }

            return inputStream;
        }

        @Override
        public InputStream getErrorStream() {
            return null;
        }

        @Override
        public int waitFor() throws InterruptedException {
            return 0;
        }

        @Override
        public int exitValue() {
            return 0;
        }

        @Override

   * @since 33.4.0 (but since 28.0 in the JRE flavor)
   */
  @IgnoreJRERequirement // Users will use this only if they're already using Duration.
  public boolean waitFor(Guard guard, Duration time) throws InterruptedException {
    return waitFor(guard, toNanosSaturated(time), NANOSECONDS);
  }

  /**
   * Waits for the guard to be satisfied. Waits at most the given time, and may be interrupted. May

    return method.getName().startsWith("enterIf");
  }

  /** Identifies all waitForXxx methods, which must be called while occupying the monitor. */
  private static boolean isWaitFor(Method method) {
    return method.getName().startsWith("waitFor");
  }

  /** Determines whether the given method takes a Guard as its first parameter. */
  private static boolean isGuarded(Method method) {

        private final int exitValue;

        public TestProcess(int exitValue) {
            this.exitValue = exitValue;
        }

        @Override
        public int waitFor() throws InterruptedException {
            return exitValue;
        }

        @Override
        public int exitValue() {
            return exitValue;
        }

        @Override

        Process p = pb.start();
        Future<String> outFuture = readStreamAsync(p.getInputStream());
        Future<String> errFuture = readStreamAsync(p.getErrorStream());
        int code = p.waitFor();
        String out = outFuture.get();
        String err = errFuture.get();
        return new ExecResult(code, out, err);
    }

    private static Future<String> readStreamAsync(InputStream inputStream) {

        ProcessBuilder pb = new ProcessBuilder(cmd);
        Process p = pb.start();
        String out = readFully(p.getInputStream());
        String err = readFully(p.getErrorStream());
        int code = p.waitFor();
        return new ExecResult(code, out, err);
    }

    private static String readFully(InputStream in) throws IOException {

        Future<String> stdoutFuture = readStreamAsync(process.getInputStream());
        Future<String> stderrFuture = readStreamAsync(process.getErrorStream());

        int returnCode = process.waitFor();
        String stdout = stdoutFuture.get();
        String stderr = stderrFuture.get();
        return new ExecResult(stdout, stderr, returnCode);
    }