/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   *   https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  package org.apache.commons.exec;
  
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertNotNull;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  import static org.junit.jupiter.api.Assertions.fail;
  
  import java.io.BufferedReader;
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.time.Duration;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.exec.environment.EnvironmentUtils;
  import org.apache.commons.lang3.SystemProperties;
  import org.junit.jupiter.api.AfterEach;
  import org.junit.jupiter.api.BeforeAll;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Disabled;
  import org.junit.jupiter.api.Test;
  import org.junit.jupiter.api.condition.DisabledOnOs;
  import org.junitpioneer.jupiter.SetSystemProperty;
  
  /**
   */
  //turn on debug mode and throw an exception for each encountered problem
  @SetSystemProperty(key = "org.apache.commons.exec.lenient", value = "false")
  @SetSystemProperty(key = "org.apache.commons.exec.debug", value = "true")
  class DefaultExecutorTest {
  
      /** Maximum time to wait (15s) */
      private static final int WAITFOR_TIMEOUT = 15_000;
      private static final Duration WAITFOR_TIMEOUT_D = Duration.ofMillis(WAITFOR_TIMEOUT);
  
      // Get suitable exit codes for the OS
      private static int successStatus; // test script successful exit code
      private static int errorStatus; // test script error exit code
  
      @BeforeAll
      public static void classSetUp() {
          final int[] statuses = TestUtil.getTestScriptCodesForOS();
          successStatus = statuses[0];
          errorStatus = statuses[1];
      }
  
      private final Executor exec = DefaultExecutor.builder().get();
  
      private final File testDir = new File("src/test/scripts");
      private final File foreverOutputFile = new File("./target/forever.txt");
      private ByteArrayOutputStream baos;
      private final Path testScript = TestUtil.resolveScriptPathForOS(testDir + "/test");
      private final Path errorTestScript = TestUtil.resolveScriptPathForOS(testDir + "/error");
      private final Path foreverTestScript = TestUtil.resolveScriptPathForOS(testDir + "/forever");
      private final Path nonExistingTestScript = TestUtil.resolveScriptPathForOS(testDir + "/grmpffffff");
      private final Path redirectScript = TestUtil.resolveScriptPathForOS(testDir + "/redirect");
  
      private final Path printArgsScript = TestUtil.resolveScriptPathForOS(testDir + "/printargs");
      // private final File acroRd32Script = TestUtil.resolveScriptForOS(testDir + "/acrord32");
      private final Path stdinSript = TestUtil.resolveScriptPathForOS(testDir + "/stdin");
  
      private final Path environmentSript = TestUtil.resolveScriptPathForOS(testDir + "/environment");
  //    private final File wrapperScript = TestUtil.resolveScriptForOS(testDir + "/wrapper");
  
      private int getOccurrences(final String data, final char c) {
  
          int result = 0;
  
          for (int i = 0; i < data.length(); i++) {
             if (data.charAt(i) == c) {
                 result++;
             }
         }
 
         return result;
     }
 
     private String readFile(final File file) throws Exception {
         String text;
         final StringBuilder contents = new StringBuilder();
         try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
             while ((text = reader.readLine()) != null) {
                 contents.append(text).append(System.lineSeparator());
             }
         }
         return contents.toString();
     }
 
     @BeforeEach
     public void setUp() throws Exception {
 
         // delete the marker file
         this.foreverOutputFile.getParentFile().mkdirs();
         if (this.foreverOutputFile.exists()) {
             this.foreverOutputFile.delete();
         }
 
         // prepare a ready to Executor
         this.baos = new ByteArrayOutputStream();
         this.exec.setStreamHandler(new PumpStreamHandler(baos, baos));
     }
 
     @AfterEach
     public void tearDown() throws Exception {
         this.baos.close();
         foreverOutputFile.delete();
     }
 
     @Test
     void testAddEnvironmentVariableEmbeddedQuote() throws Exception {
         final Map<String, String> myEnvVars = new HashMap<>(EnvironmentUtils.getProcEnvironment());
         final String name = "NEW_VAR";
         final String value = "NEW_\"_VAL";
         myEnvVars.put(name, value);
         exec.execute(new CommandLine(environmentSript), myEnvVars);
         final String environment = baos.toString().trim();
         assertTrue(environment.contains(name), () -> "Expecting " + name + " in " + environment);
         assertTrue(environment.contains(value), () -> "Expecting " + value + " in " + environment);
     }
 
     /**
      * Call a script to dump the environment variables of the subprocess after adding a custom environment variable.
      *
      * @throws Exception the test failed
      */
     @Test
     void testAddEnvironmentVariables() throws Exception {
         final Map<String, String> myEnvVars = new HashMap<>(EnvironmentUtils.getProcEnvironment());
         myEnvVars.put("NEW_VAR", "NEW_VAL");
         exec.execute(new CommandLine(environmentSript), myEnvVars);
         final String environment = baos.toString().trim();
         assertTrue(environment.contains("NEW_VAR"), () -> "Expecting NEW_VAR in " + environment);
         assertTrue(environment.contains("NEW_VAL"), () -> "Expecting NEW_VAL in " + environment);
     }
 
     /**
      * Call a script to dump the environment variables of the subprocess.
      *
      * @throws Exception the test failed
      */
     @Test
     void testEnvironmentVariables() throws Exception {
         exec.execute(new CommandLine(environmentSript));
         final String environment = baos.toString().trim();
         assertFalse(environment.isEmpty(), "Found no environment variables");
         assertFalse(environment.contains("NEW_VAR"));
     }
 
     /**
      * The simplest possible test - start a script and check that the output was pumped into our {@code ByteArrayOutputStream}.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecute() throws Exception {
         final CommandLine cl = new CommandLine(testScript);
         final int exitValue = exec.execute(cl);
         assertEquals("FOO..", baos.toString().trim());
         assertFalse(exec.isFailure(exitValue));
         assertEquals(new File("."), exec.getWorkingDirectory());
         assertEquals(Paths.get("."), exec.getWorkingDirectoryPath());
     }
 
     /**
      * Start an asynchronous process which returns a success exit value.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteAsync() throws Exception {
         final CommandLine cl = new CommandLine(testScript);
         final DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
         exec.execute(cl, resultHandler);
         resultHandler.waitFor(2000);
         assertTrue(resultHandler.hasResult());
         assertNull(resultHandler.getException());
         assertFalse(exec.isFailure(resultHandler.getExitValue()));
         assertEquals("FOO..", baos.toString().trim());
     }
 
     /**
      * Try to start a non-existing application where the exception is caught/processed by the result handler.
      */
     @Test
     void testExecuteAsyncNonExistingApplication() throws Exception {
         final CommandLine cl = new CommandLine(nonExistingTestScript);
         final DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
         final DefaultExecutor executor = DefaultExecutor.builder().get();
 
         executor.execute(cl, resultHandler);
         resultHandler.waitFor();
 
         assertTrue(executor.isFailure(resultHandler.getExitValue()));
         assertNotNull(resultHandler.getException());
     }
 
     /**
      * Try to start a non-existing application where the exception is caught/processed by the result handler. The watchdog in notified to avoid waiting for the
      * process infinitely.
      *
      * @see <a href="https://issues.apache.org/jira/browse/EXEC-71">EXEC-71</a>
      */
     @Test
     void testExecuteAsyncNonExistingApplicationWithWatchdog() throws Exception {
         final CommandLine cl = new CommandLine(nonExistingTestScript);
         final DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler() {
             @Override
             public void onProcessFailed(final ExecuteException e) {
                 System.out.println("Process did not stop gracefully, had exception '" + e.getMessage() + "' while executing process");
                 super.onProcessFailed(e);
             }
         };
         final DefaultExecutor executor = DefaultExecutor.builder().get();
         executor.setWatchdog(new ExecuteWatchdog(ExecuteWatchdog.INFINITE_TIMEOUT));
 
         executor.execute(cl, resultHandler);
         resultHandler.waitFor();
 
         assertTrue(executor.isFailure(resultHandler.getExitValue()));
         assertNotNull(resultHandler.getException());
         assertFalse(executor.getWatchdog().isWatching());
         assertFalse(executor.getWatchdog().killedProcess());
         executor.getWatchdog().destroyProcess();
     }
 
     /**
      * Start an asynchronous process which returns an error exit value.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteAsyncWithError() throws Exception {
         final CommandLine cl = new CommandLine(errorTestScript);
         final DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
         exec.execute(cl, resultHandler);
         resultHandler.waitFor(2000);
         assertTrue(resultHandler.hasResult());
         assertTrue(exec.isFailure(resultHandler.getExitValue()));
         assertNotNull(resultHandler.getException());
         assertEquals("FOO..", baos.toString().trim());
     }
 
     /**
      * Test the proper handling of ProcessDestroyer for an asynchronous process. Since we do not terminate the process it will be terminated in the
      * ShutdownHookProcessDestroyer implementation.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteAsyncWithProcessDestroyer() throws Exception {
 
         final CommandLine cl = new CommandLine(foreverTestScript);
         final DefaultExecuteResultHandler handler = new DefaultExecuteResultHandler();
         final ShutdownHookProcessDestroyer processDestroyer = new ShutdownHookProcessDestroyer();
         final ExecuteWatchdog watchdog = new ExecuteWatchdog(Integer.MAX_VALUE);
 
         assertNull(exec.getProcessDestroyer());
         assertTrue(processDestroyer.isEmpty());
         assertFalse(processDestroyer.isAddedAsShutdownHook());
 
         exec.setWatchdog(watchdog);
         exec.setProcessDestroyer(processDestroyer);
         exec.execute(cl, handler);
 
         // wait for script to start
         Thread.sleep(2000);
 
         // our process destroyer should be initialized now
         assertNotNull(exec.getProcessDestroyer(), "Process destroyer should exist");
         assertEquals(1, processDestroyer.size(), "Process destroyer size should be 1");
         assertTrue(processDestroyer.isAddedAsShutdownHook(), "Process destroyer should exist as shutdown hook");
 
         // terminate it and the process destroyer is detached
         watchdog.destroyProcess();
         assertTrue(watchdog.killedProcess());
         handler.waitFor(WAITFOR_TIMEOUT);
         assertTrue(handler.hasResult(), "ResultHandler received a result");
         assertNotNull(handler.getException());
         assertEquals(0, processDestroyer.size(), "Processor Destroyer size should be 0");
         assertFalse(processDestroyer.isAddedAsShutdownHook(), "Process destroyer should not exist as shutdown hook");
     }
 
     /**
      * Start an asynchronous process and terminate it manually before the watchdog timeout occurs.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteAsyncWithTimelyUserTermination() throws Exception {
         final CommandLine cl = new CommandLine(foreverTestScript);
         final ExecuteWatchdog watchdog = new ExecuteWatchdog(Integer.MAX_VALUE);
         exec.setWatchdog(watchdog);
         final DefaultExecuteResultHandler handler = new DefaultExecuteResultHandler();
         exec.execute(cl, handler);
         // wait for script to run
         Thread.sleep(2000);
         assertTrue(watchdog.isWatching(), "Watchdog should watch the process");
         // terminate it manually using the watchdog
         watchdog.destroyProcess();
         // wait until the result of the process execution is propagated
         handler.waitFor(WAITFOR_TIMEOUT);
         assertTrue(watchdog.killedProcess(), "Watchdog should have killed the process");
         assertFalse(watchdog.isWatching(), "Watchdog is no longer watching the process");
         assertTrue(handler.hasResult(), "ResultHandler received a result");
         assertNotNull(handler.getException(), "ResultHandler received an exception as result");
     }
 
     /**
      * Start an asynchronous process and try to terminate it manually but the process was already terminated by the watchdog. This is basically a race condition
      * between infrastructure and user code.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteAsyncWithTooLateUserTermination() throws Exception {
         final CommandLine cl = new CommandLine(foreverTestScript);
         final DefaultExecuteResultHandler handler = new DefaultExecuteResultHandler();
         final ExecuteWatchdog watchdog = new ExecuteWatchdog(3000);
         exec.setWatchdog(watchdog);
         exec.execute(cl, handler);
         // wait for script to be terminated by the watchdog
         Thread.sleep(6000);
         // try to terminate the already terminated process
         watchdog.destroyProcess();
         // wait until the result of the process execution is propagated
         handler.waitFor(WAITFOR_TIMEOUT);
         assertTrue(watchdog.killedProcess(), "Watchdog should have killed the process already");
         assertFalse(watchdog.isWatching(), "Watchdog is no longer watching the process");
         assertTrue(handler.hasResult(), "ResultHandler received a result");
         assertNotNull(handler.getException(), "ResultHandler received an exception as result");
     }
 
     /**
      * Try to start a non-existing application which should result in an exception.
      */
     @Test
     void testExecuteNonExistingApplication() throws Exception {
         final CommandLine cl = new CommandLine(nonExistingTestScript);
         final DefaultExecutor executor = DefaultExecutor.builder().get();
 
         assertThrows(IOException.class, () -> executor.execute(cl));
     }
 
     /**
      * Try to start a non-existing application which should result in an exception.
      */
     @Test
     void testExecuteNonExistingApplicationWithWatchDog() throws Exception {
         final CommandLine cl = new CommandLine(nonExistingTestScript);
         final DefaultExecutor executor = DefaultExecutor.builder().get();
         executor.setWatchdog(new ExecuteWatchdog(ExecuteWatchdog.INFINITE_TIMEOUT));
 
         assertThrows(IOException.class, () -> executor.execute(cl));
     }
 
     /**
      * Start any processes in a loop to make sure that we do not leave any handles/resources open.
      *
      * @throws Exception the test failed
      */
     @Test
     @Disabled
     void testExecuteStability() throws Exception {
 
         // make a plain-vanilla test
         for (int i = 0; i < 100; i++) {
             final Map<String, String> env = new HashMap<>();
             env.put("TEST_ENV_VAR", Integer.toString(i));
             final CommandLine cl = new CommandLine(testScript);
             final int exitValue = exec.execute(cl, env);
             assertFalse(exec.isFailure(exitValue));
             assertEquals("FOO." + i + ".", baos.toString().trim());
             baos.reset();
         }
 
         // now be nasty and use the watchdog to kill out sub-processes
         for (int i = 0; i < 100; i++) {
             final Map<String, String> env = new HashMap<>();
             env.put("TEST_ENV_VAR", Integer.toString(i));
             final DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
             final CommandLine cl = new CommandLine(foreverTestScript);
             final ExecuteWatchdog watchdog = new ExecuteWatchdog(500);
             exec.setWatchdog(watchdog);
             exec.execute(cl, env, resultHandler);
             resultHandler.waitFor(WAITFOR_TIMEOUT);
             assertTrue(resultHandler.hasResult(), "ResultHandler received a result");
             assertNotNull(resultHandler.getException());
             baos.reset();
         }
     }
 
     /**
      * Start a script looping forever (asynchronously) and check if the ExecuteWatchdog kicks in killing the runaway process. To make killing a process more
      * testable the "forever" scripts write each second a '.' into "./target/forever.txt" (a marker file). After a test run we should have a few dots in there.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWatchdogAsync() throws Exception {
 
         final long timeout = 10000;
 
         final CommandLine cl = new CommandLine(foreverTestScript);
         final DefaultExecuteResultHandler handler = new DefaultExecuteResultHandler();
         final DefaultExecutor executor = DefaultExecutor.builder().get();
         executor.setWorkingDirectory(new File("."));
         executor.setWatchdog(new ExecuteWatchdog(timeout));
 
         executor.execute(cl, handler);
         handler.waitFor(WAITFOR_TIMEOUT);
 
         assertTrue(executor.getWatchdog().killedProcess(), "Killed process should be true");
         assertTrue(handler.hasResult(), "ResultHandler received a result");
         assertNotNull(handler.getException(), "ResultHandler received an exception as result");
 
         final int nrOfInvocations = getOccurrences(readFile(this.foreverOutputFile), '.');
         assertTrue(nrOfInvocations > 5 && nrOfInvocations <= 11, () -> "Killing the process did not work : " + nrOfInvocations);
     }
 
     /**
      * Start a script looping forever (synchronously) and check if the ExecuteWatchdog kicks in killing the runaway process. To make killing a process more
      * testable the "forever" scripts write each second a '.' into "./target/forever.txt" (a marker file). After a test run we should have a few dots in there.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWatchdogSync() throws Exception {
 
         if (OS.isFamilyOpenVms()) {
             System.out.println("The test 'testExecuteWatchdogSync' currently hangs on the following OS : " + SystemProperties.getOsName());
             return;
         }
 
         final long timeout = 10000;
 
         final CommandLine cl = new CommandLine(foreverTestScript);
         final DefaultExecutor executor = DefaultExecutor.builder().get();
         executor.setWorkingDirectory(new File("."));
         final ExecuteWatchdog watchdog = new ExecuteWatchdog(timeout);
         executor.setWatchdog(watchdog);
 
         try {
             executor.execute(cl);
         } catch (final ExecuteException e) {
             Thread.sleep(timeout);
             final int nrOfInvocations = getOccurrences(readFile(this.foreverOutputFile), '.');
             assertTrue(executor.getWatchdog().killedProcess());
             assertTrue(nrOfInvocations > 5 && nrOfInvocations <= 11, () -> "killing the subprocess did not work : " + nrOfInvocations);
             return;
         } catch (final Throwable t) {
             fail(t.getMessage());
         }
 
         assertTrue(executor.getWatchdog().killedProcess(), "Killed process should be true");
         fail("Process did not create ExecuteException when killed");
     }
 
     /**
      * [EXEC-68] Synchronously starts a short script with a Watchdog attached with an extremely large timeout. Checks to see if the script terminated naturally
      * or if it was killed by the Watchdog. Fail if killed by Watchdog.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWatchdogVeryLongTimeout() throws Exception {
         final long timeout = Long.MAX_VALUE;
 
         final CommandLine cl = new CommandLine(testScript);
         final DefaultExecutor executor = DefaultExecutor.builder().get();
         executor.setWorkingDirectory(new File("."));
         final ExecuteWatchdog watchdog = new ExecuteWatchdog(timeout);
         executor.setWatchdog(watchdog);
 
         try {
             executor.execute(cl);
         } catch (final ExecuteException e) {
             assertFalse(watchdog.killedProcess(), "Process should exit normally, not be killed by watchdog");
             // If the Watchdog did not kill it, something else went wrong.
             throw e;
         }
     }
 
     @Test
     void testExecuteWithArg() throws Exception {
         final CommandLine cl = new CommandLine(testScript);
         cl.addArgument("BAR");
         final int exitValue = exec.execute(cl);
 
         assertEquals("FOO..BAR", baos.toString().trim());
         assertFalse(exec.isFailure(exitValue));
     }
 
     /**
      * A generic test case to print the command line arguments to 'printargs' script to solve even more command line puzzles.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWithComplexArguments() throws Exception {
         final CommandLine cl = new CommandLine(printArgsScript);
         cl.addArgument("gdal_translate");
         cl.addArgument("HDF5:\"/home/kk/grass/data/4404.he5\"://HDFEOS/GRIDS/OMI_Column_Amount_O3/Data_Fields/ColumnAmountO3/home/kk/4.tif", false);
         final DefaultExecutor executor = DefaultExecutor.builder().get();
         final int exitValue = executor.execute(cl);
         assertFalse(exec.isFailure(exitValue));
     }
 
     /**
      * Invoke the error script but define that the ERROR_STATUS is a good exit value and therefore no exception should be thrown.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWithCustomExitValue1() throws Exception {
         exec.setExitValue(errorStatus);
         final CommandLine cl = new CommandLine(errorTestScript);
         exec.execute(cl);
     }
 
     /**
      * Invoke the error script but define that SUCCESS_STATUS is a bad exit value and therefore an exception should be thrown.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWithCustomExitValue2() throws Exception {
         final CommandLine cl = new CommandLine(errorTestScript);
         exec.setExitValue(successStatus);
         try {
             exec.execute(cl);
             fail("Must throw ExecuteException");
         } catch (final ExecuteException e) {
             assertTrue(exec.isFailure(e.getExitValue()));
         }
     }
 
     @Test
     void testExecuteWithError() throws Exception {
         final CommandLine cl = new CommandLine(errorTestScript);
 
         try {
             exec.execute(cl);
             fail("Must throw ExecuteException");
         } catch (final ExecuteException e) {
             assertTrue(exec.isFailure(e.getExitValue()));
         }
     }
 
     /**
      * Invoke the test using some fancy arguments.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWithFancyArg() throws Exception {
         final CommandLine cl = new CommandLine(testScript);
         cl.addArgument("test $;`(0)[1]{2}");
         final int exitValue = exec.execute(cl);
         assertTrue(baos.toString().trim().indexOf("test $;`(0)[1]{2}") > 0);
         assertFalse(exec.isFailure(exitValue));
     }
 
     @Test
     void testExecuteWithInvalidWorkingDirectory() throws Exception {
         final File workingDir = new File("/foo/bar");
         final CommandLine cl = new CommandLine(testScript);
         exec.setWorkingDirectory(workingDir);
 
         assertThrows(IOException.class, () -> exec.execute(cl));
     }
 
     /**
      * Start a process and connect it to no stream.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWithNullOutErr() throws Exception {
         final CommandLine cl = new CommandLine(testScript);
         final PumpStreamHandler pumpStreamHandler = new PumpStreamHandler(null, null);
         final DefaultExecutor executor = DefaultExecutor.builder().get();
         executor.setStreamHandler(pumpStreamHandler);
         final int exitValue = executor.execute(cl);
         assertFalse(exec.isFailure(exitValue));
     }
 
     /**
      * Test the proper handling of ProcessDestroyer for a synchronous process.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWithProcessDestroyer() throws Exception {
 
         final CommandLine cl = new CommandLine(testScript);
         final ShutdownHookProcessDestroyer processDestroyer = new ShutdownHookProcessDestroyer();
         exec.setProcessDestroyer(processDestroyer);
 
         assertTrue(processDestroyer.isEmpty());
         assertFalse(processDestroyer.isAddedAsShutdownHook());
 
         final int exitValue = exec.execute(cl);
 
         assertEquals("FOO..", baos.toString().trim());
         assertFalse(exec.isFailure(exitValue));
         assertTrue(processDestroyer.isEmpty());
         assertFalse(processDestroyer.isAddedAsShutdownHook());
     }
 
     /**
      * Start a process with redirected streams - stdin of the newly created process is connected to a FileInputStream whereas the "redirect" script reads all
      * lines from stdin and prints them on stdout. Furthermore, the script prints a status message on stderr.
      *
      * @throws Exception the test failed
      */
     @Test
     @DisabledOnOs(org.junit.jupiter.api.condition.OS.WINDOWS)
     void testExecuteWithRedirectedStreams() throws Exception {
         final int exitValue;
         try (FileInputStream fis = new FileInputStream("./NOTICE.txt")) {
             final CommandLine cl = new CommandLine(redirectScript);
             final PumpStreamHandler pumpStreamHandler = new PumpStreamHandler(baos, baos, fis);
             final DefaultExecutor executor = DefaultExecutor.builder().get();
             executor.setWorkingDirectory(new File("."));
             executor.setStreamHandler(pumpStreamHandler);
             exitValue = executor.execute(cl);
         }
         final String result = baos.toString().trim();
         assertTrue(result.indexOf("Finished reading from stdin") > 0, result);
         assertFalse(exec.isFailure(exitValue), () -> "exitValue=" + exitValue);
     }
 
     /**
      * Start a process and connect out and err to a file.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWithRedirectOutErr() throws Exception {
         final Path outFile = Files.createTempFile("EXEC", ".test");
         final CommandLine cl = new CommandLine(testScript);
         try (OutputStream outAndErr = Files.newOutputStream(outFile)) {
             final PumpStreamHandler pumpStreamHandler = new PumpStreamHandler(outAndErr);
             final DefaultExecutor executor = DefaultExecutor.builder().get();
             executor.setStreamHandler(pumpStreamHandler);
             final int exitValue = executor.execute(cl);
             assertFalse(exec.isFailure(exitValue));
             assertTrue(Files.exists(outFile));
         } finally {
             Files.delete(outFile);
         }
     }
 
     /**
      * Execute the test script and pass an environment containing 'TEST_ENV_VAR'.
      */
     @Test
     void testExecuteWithSingleEnvironmentVariable() throws Exception {
         final Map<String, String> env = new HashMap<>();
         env.put("TEST_ENV_VAR", "XYZ");
 
         final CommandLine cl = new CommandLine(testScript);
 
         final int exitValue = exec.execute(cl, env);
 
         assertEquals("FOO.XYZ.", baos.toString().trim());
         assertFalse(exec.isFailure(exitValue));
     }
 
     // ======================================================================
     // === Long running tests
     // ======================================================================
 
     /**
      * Start a process and connect stdout and stderr.
      *
      * @throws Exception the test failed
      */
     @Test
     void testExecuteWithStdOutErr() throws Exception {
         final CommandLine cl = new CommandLine(testScript);
         final PumpStreamHandler pumpStreamHandler = new PumpStreamHandler(System.out, System.err);
         final DefaultExecutor executor = DefaultExecutor.builder().get();
         executor.setStreamHandler(pumpStreamHandler);
         final int exitValue = executor.execute(cl);
         assertFalse(exec.isFailure(exitValue));
     }
 
     // ======================================================================
     // === Helper methods
     // ======================================================================
 
     @Test
     void testExecuteWithWorkingDirectory() throws Exception {
         final Path workingDirPath = Paths.get("./target");
         final CommandLine cl = new CommandLine(testScript);
         final File workingDirFile = workingDirPath.toFile();
         exec.setWorkingDirectory(workingDirFile);
         final int exitValue = exec.execute(cl);
         assertEquals("FOO..", baos.toString().trim());
         assertFalse(exec.isFailure(exitValue));
         assertEquals(exec.getWorkingDirectory(), workingDirFile);
         assertEquals(exec.getWorkingDirectoryPath(), workingDirPath);
     }
 
     /**
      * The test script reads an argument from {@code stdin} and prints the result to stdout. To make things slightly more interesting we are using an
      * asynchronous process.
      *
      * @throws Exception the test failed
      */
     @Test
     void testStdInHandling() throws Exception {
         // newline not needed; causes problems for VMS
         final ByteArrayInputStream bais = new ByteArrayInputStream("Foo".getBytes());
         final CommandLine cl = new CommandLine(this.stdinSript);
         final PumpStreamHandler pumpStreamHandler = new PumpStreamHandler(this.baos, System.err, bais);
         final DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
         final Executor executor = DefaultExecutor.builder().get();
         executor.setStreamHandler(pumpStreamHandler);
         executor.execute(cl, resultHandler);
 
         resultHandler.waitFor(WAITFOR_TIMEOUT);
         assertTrue(resultHandler.hasResult(), "ResultHandler received a result");
 
         assertFalse(exec.isFailure(resultHandler.getExitValue()));
         final String result = baos.toString();
         assertTrue(result.contains("Hello Foo!"), "Result '" + result + "' should contain 'Hello Foo!'");
     }
 }