cleanup process utils

Author: mtf90

CHANGELOG.md

@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Changed
 
 * AutomataLib now requires Java 11 at runtime.
+* `ProcessUtil#invokeProcess` now handles consumers for stdout and stderr separately.
 
 ### Removed
 

commons/util/src/main/java/net/automatalib/common/util/process/InputStreamConsumer.java

@@ -18,6 +18,7 @@
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.util.function.Consumer;
 
 import net.automatalib.common.util.IOUtil;
@@ -30,16 +31,19 @@ interface InputStreamConsumer {
     void consume(InputStream is) throws IOException;
 
     /**
-     * Consumes an input stream by throwing away all of its content.
+     * Consumes an input stream by copying it to a given output stream.
      */
-    class NOPConsumer implements InputStreamConsumer {
+    class CopyConsumer implements InputStreamConsumer {
+
+        private final OutputStream outputStream;
+
+        CopyConsumer(OutputStream outputStream) {
+            this.outputStream = outputStream;
+        }
 
         @Override
         public void consume(InputStream inputStream) throws IOException {
-            final byte[] buf = new byte[IOUtil.DEFAULT_BUFFER_SIZE];
-            while (inputStream.read(buf) >= 0) {
-                // do nothing
-            }
+            inputStream.transferTo(outputStream);
         }
     }
 

commons/util/src/main/java/net/automatalib/common/util/process/ProcessUtil.java

@@ -0,0 +1,95 @@
+/* Copyright (C) 2013-2025 TU Dortmund University
+ * This file is part of AutomataLib <https://automatalib.net>.
+ *
+ * Licensed 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
+ *
+ *     http://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 net.automatalib.common.util.process;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.Objects;
+import java.util.StringJoiner;
+
+import org.testng.Assert;
+import org.testng.SkipException;
+import org.testng.annotations.BeforeTest;
+import org.testng.annotations.Test;
+
+@Test
+public class ProcessUtilTest {
+
+    private final String process;
+
+    public ProcessUtilTest() {
+        this.process = Objects.requireNonNull(ProcessUtilTest.class.getResource("/process.py")).getPath();
+    }
+
+    @BeforeTest
+    public void setUp() {
+        try {
+            if (ProcessUtil.invokeProcess(new String[] {"python", "--version"}) != 0) {
+                throw new SkipException("python not supported");
+            }
+        } catch (IOException | InterruptedException e) {
+            throw new SkipException("python not supported");
+        }
+    }
+
+    @Test
+    public void testReturnValue() throws IOException, InterruptedException {
+        Assert.assertEquals(ProcessUtil.invokeProcess(new String[] {process, "abc"}), 0);
+        Assert.assertEquals(ProcessUtil.invokeProcess(new String[] {process, "abc", "def"}), 1);
+
+        Assert.assertEquals(ProcessUtil.invokeProcess(new String[] {process}, new StringReader("abc")), 0);
+        Assert.assertEquals(ProcessUtil.invokeProcess(new String[] {process}, new StringReader("abc def")), 1);
+    }
+
+    @Test
+    public void testProcessOutput() throws IOException, InterruptedException {
+        StringJoiner stdOutJoiner = new StringJoiner("\n");
+        StringJoiner stdErrBuilder = new StringJoiner("\n");
+
+        Assert.assertEquals(ProcessUtil.invokeProcess(new String[] {process, "abc"},
+                                                      stdOutJoiner::add,
+                                                      stdErrBuilder::add), 0);
+        Assert.assertEquals(stdOutJoiner.toString(), "294");
+        Assert.assertEquals(stdErrBuilder.toString(), "abc");
+
+        stdOutJoiner = new StringJoiner("\n");
+        stdErrBuilder = new StringJoiner("\n");
+        Assert.assertEquals(ProcessUtil.invokeProcess(new String[] {process, "abc", "def"},
+                                                      stdOutJoiner::add,
+                                                      stdErrBuilder::add), 1);
+        Assert.assertEquals(stdOutJoiner.toString(), "294\n303");
+        Assert.assertEquals(stdErrBuilder.toString(), "abc\ndef");
+
+        stdOutJoiner = new StringJoiner("\n");
+        stdErrBuilder = new StringJoiner("\n");
+        Assert.assertEquals(ProcessUtil.invokeProcess(new String[] {process},
+                                                      new StringReader("abc"),
+                                                      stdOutJoiner::add,
+                                                      stdErrBuilder::add), 0);
+        Assert.assertEquals(stdOutJoiner.toString(), "294");
+        Assert.assertEquals(stdErrBuilder.toString(), "abc");
+
+        stdOutJoiner = new StringJoiner("\n");
+        stdErrBuilder = new StringJoiner("\n");
+        Assert.assertEquals(ProcessUtil.invokeProcess(new String[] {process},
+                                                      new StringReader("abc def"),
+                                                      stdOutJoiner::add,
+                                                      stdErrBuilder::add), 1);
+        Assert.assertEquals(stdOutJoiner.toString(), "294\n303");
+        Assert.assertEquals(stdErrBuilder.toString(), "abc\ndef");
+
+    }
+}

commons/util/src/test/java/net/automatalib/common/util/process/ProcessUtilTest.java

@@ -0,0 +1,21 @@
+#!/bin/python
+import sys
+
+def main():
+    argv = len(sys.argv)
+
+    if argv > 1: # arg mode
+        for arg in sys.argv[1:]:
+            print(sum([ord(c) for c in arg]))
+            print(arg, file=sys.stderr)
+    else: # stdin mode
+        for line in sys.stdin:
+            for arg in line.split():
+                argv += 1
+                print(sum([ord(c) for c in arg]))
+                print(arg, file=sys.stderr)
+
+    sys.exit(argv % 2)
+
+if __name__ == "__main__":
+    main()

commons/util/src/test/resources/process.py

@@ -46,7 +46,7 @@ private DOTExample() {
         // prevent instantiation
     }
 
-    public static void main(String[] args) throws IOException {
+    public static void main(String[] args) throws IOException, InterruptedException {
         if (DOT.checkUsable()) {
             final Random r = new Random(42);
             final List<Pair<String, String>> graphs = Arrays.asList(Pair.of("Automaton 1", generateRandomAutomaton(r)),

examples/src/main/java/net/automatalib/example/dot/DOTExample.java

@@ -78,7 +78,7 @@ public void testDOTExample() throws InvocationTargetException, InterruptedExcept
         SwingUtilities.invokeAndWait(() -> {
             try {
                 DOTExample.main(new String[0]);
-            } catch (IOException e) {
+            } catch (IOException | InterruptedException e) {
                 throw new RuntimeException(e);
             }
         });

examples/src/test/java/net/automatalib/example/ExamplesTest.java

@@ -284,8 +284,8 @@ public Function<String, I> getString2Input() {
 
     private static int runCommandLine(List<String> commandLine) {
         try {
-            LOGGER.debug("Invoking LTSmin binary as: {}", String.join(" ", commandLine));
-            return ProcessUtil.invokeProcess(commandLine, LOGGER::debug);
+            LOGGER.debug("Invoking LTSmin binary as: '{}'", String.join(" ", commandLine));
+            return ProcessUtil.invokeProcess(commandLine, LOGGER::debug, LOGGER::warn);
         } catch (IOException | InterruptedException e) {
             throw new ModelCheckingException(e);
         }

modelchecking/ltsmin/src/main/java/net/automatalib/modelchecker/ltsmin/AbstractLTSmin.java

@@ -176,7 +176,7 @@ public static void detectLTSmin() {
         final StringWriter stringWriter = new StringWriter();
 
         try {
-            final int exitValue = ProcessUtil.invokeProcess(commandLine, stringWriter::append);
+            final int exitValue = ProcessUtil.invokeProcess(commandLine, stringWriter::append, LOGGER::warn);
 
             if (exitValue == VERSION_EXIT) {
                 return LTSminVersion.parse(stringWriter.toString());