hcoles · hcoles · Jul 14, 2022 · Jul 13, 2022
diff --git a/README.md b/README.md
@@ -8,6 +8,10 @@ Read all about it at http://pitest.org
 
 ## Releases
 
+### 1.9.3 (unreleased)
+
+* #1052 - Support maven argLine property and single string argLines
+
 ### 1.9.2
 
 * #1050 - Check minions are alive to prevent process hangs

diff --git a/pitest-ant/src/main/java/org/pitest/ant/PitestTask.java b/pitest-ant/src/main/java/org/pitest/ant/PitestTask.java
@@ -260,6 +260,10 @@ public void setOutputEncoding(String value) {
     this.setOption(ConfigOption.OUTPUT_ENCODING, value);
   }
 
+  public void setArgLine(String value) {
+    this.setOption(ConfigOption.ARG_LINE, value);
+  }
+
   private void setOption(final ConfigOption option, final String value) {
     if (!"".equals(value)) {
       this.options.put(option.getParamName(), value);
@@ -271,4 +275,5 @@ public void setUseClasspathJar(String value) {
   }
 
 
+
 }
diff --git a/pitest-ant/src/test/java/org/pitest/ant/PitestTaskTest.java b/pitest-ant/src/test/java/org/pitest/ant/PitestTaskTest.java
@@ -489,6 +489,12 @@ public void passesOutputEncodingToJavaTask() {
     verify(this.arg).setValue("--outputEncoding=US-ASCII");
   }
 
+  @Test
+  public void passesArgLineToJavaTask() {
+    this.pitestTask.setArgLine("-Dfoo=\"bar\"");
+    this.pitestTask.execute(this.java);
+    verify(this.arg).setValue("--argLine=-Dfoo=\"bar\"");
+  }
 
   private static class PathMatcher implements ArgumentMatcher<Path> {
 

diff --git a/pitest-command-line/src/main/java/org/pitest/mutationtest/commandline/OptionsParser.java b/pitest-command-line/src/main/java/org/pitest/mutationtest/commandline/OptionsParser.java
@@ -43,6 +43,7 @@
 import java.util.function.Predicate;
 import java.util.logging.Logger;
 
+import static org.pitest.mutationtest.config.ConfigOption.ARG_LINE;
 import static org.pitest.mutationtest.config.ConfigOption.AVOID_CALLS;
 import static org.pitest.mutationtest.config.ConfigOption.CHILD_JVM;
 import static org.pitest.mutationtest.config.ConfigOption.CLASSPATH;
@@ -107,6 +108,7 @@ public class OptionsParser {
   private final OptionSpec<File>                     historyInputSpec;
   private final OptionSpec<String>                   mutators;
   private final OptionSpec<String>                   features;
+  private final OptionSpec<String>                   argLine;
   private final OptionSpec<String>                   jvmArgs;
   private final CommaAwareArgsProcessor              jvmArgsProcessor;
   private final OptionSpec<Float>                    timeoutFactorSpec;
@@ -203,6 +205,9 @@ public OptionsParser(Predicate<String> dependencyFilter) {
         .ofType(String.class).withValuesSeparatedBy(',')
         .describedAs("comma separated list of features to enable/disable.");
 
+    this.argLine = parserAccepts(ARG_LINE).withRequiredArg()
+            .describedAs("argline for child JVMs");
+
     this.jvmArgs = parserAccepts(CHILD_JVM).withRequiredArg()
         .describedAs("comma separated list of child JVM args");
 
@@ -416,6 +421,8 @@ private ParseResult parseCommandLine(final ReportOptions data,
     data.setMutators(this.mutators.values(userArgs));
     data.setFeatures(this.features.values(userArgs));
 
+    data.setArgLine(this.argLine.value(userArgs));
+
     data.addChildJVMArgs(this.jvmArgsProcessor.values(userArgs));
 
     data.setFullMutationMatrix(this.fullMutationMatrixSpec.value(userArgs));

diff --git a/pitest-command-line/src/test/java/org/pitest/mutationtest/commandline/OptionsParserTest.java b/pitest-command-line/src/test/java/org/pitest/mutationtest/commandline/OptionsParserTest.java
@@ -96,6 +96,13 @@ public void shouldParseCommaSeparatedListOfSourceDirectories() {
     assertEquals(Arrays.asList(new File("foo/bar"), new File("bar/far")), actual.getSourceDirs());
   }
 
+  @Test
+  public void shouldSetArgLine() {
+    final ReportOptions actual = parseAddingRequiredArgs("--argLine", "-Dfoo=\"bar\"");
+
+    assertThat(actual.getArgLine()).isEqualTo("-Dfoo=\"bar\"");
+  }
+
   @Test
   public void shouldParseCommaSeparatedListOfJVMArgs() {
     final ReportOptions actual = parseAddingRequiredArgs("--jvmArgs", "foo,bar");

diff --git a/pitest-entry/src/main/java/org/pitest/mutationtest/config/ConfigOption.java b/pitest-entry/src/main/java/org/pitest/mutationtest/config/ConfigOption.java
@@ -54,6 +54,10 @@ public enum ConfigOption {
    */
   CHILD_JVM("jvmArgs"),
 
+  /**
+   * Arguments to launch child processes with expressed as single line
+   */
+  ARG_LINE("argLine"),
 
   /**
    * Do/don't create timestamped folders for reports

diff --git a/pitest-entry/src/main/java/org/pitest/mutationtest/config/ReportOptions.java b/pitest-entry/src/main/java/org/pitest/mutationtest/config/ReportOptions.java
@@ -97,6 +97,9 @@ public class ReportOptions {
   private Collection<String>             features;
 
   private final List<String>             jvmArgs                        = new ArrayList<>(DEFAULT_CHILD_JVM_ARGS);
+
+  private String                         argLine;
+
   private int                            numberOfThreads                = 0;
   private float                          timeoutFactor                  = PercentAndConstantTimeoutStrategy.DEFAULT_FACTOR;
   private long                           timeoutConstant                = PercentAndConstantTimeoutStrategy.DEFAULT_CONSTANT;
@@ -219,6 +222,14 @@ public void addChildJVMArgs(final List<String> args) {
     this.jvmArgs.addAll(args);
   }
 
+  public String getArgLine() {
+    return argLine;
+  }
+
+  public void setArgLine(String argLine) {
+    this.argLine = argLine;
+  }
+
   public ClassPath getClassPath() {
     if (this.classPathElements != null) {
       return createClassPathFromElements();
@@ -628,6 +639,7 @@ public void setOutputEncoding(Charset outputEncoding) {
     this.outputEncoding = outputEncoding;
   }
 
+
   @Override
   public String toString() {
     return new StringJoiner(", ", ReportOptions.class.getSimpleName() + "[", "]")
@@ -644,6 +656,7 @@ public String toString() {
             .add("mutators=" + mutators)
             .add("features=" + features)
             .add("jvmArgs=" + jvmArgs)
+            .add("argLine=" + argLine)
             .add("numberOfThreads=" + numberOfThreads)
             .add("timeoutFactor=" + timeoutFactor)
             .add("timeoutConstant=" + timeoutConstant)
@@ -676,4 +689,6 @@ public String toString() {
             .add("outputEncoding=" + outputEncoding)
             .toString();
   }
+
+
 }
diff --git a/pitest-entry/src/main/java/org/pitest/mutationtest/tooling/EntryPoint.java b/pitest-entry/src/main/java/org/pitest/mutationtest/tooling/EntryPoint.java
@@ -18,6 +18,7 @@
 import org.pitest.mutationtest.incremental.WriterFactory;
 import org.pitest.plugin.Feature;
 import org.pitest.plugin.FeatureParameter;
+import org.pitest.process.ArgLineParser;
 import org.pitest.process.JavaAgent;
 import org.pitest.process.LaunchOptions;
 import org.pitest.util.Log;
@@ -28,6 +29,8 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.Reader;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.Consumer;
@@ -97,7 +100,7 @@ public AnalysisResult execute(File baseDir, ReportOptions data,
 
     final CoverageOptions coverageOptions = settings.createCoverageOptions();
     final LaunchOptions launchOptions = new LaunchOptions(ja,
-        settings.getJavaExecutable(), data.getJvmArgs(), environmentVariables)
+        settings.getJavaExecutable(), createJvmArgs(data), environmentVariables)
         .usingClassPathJar(data.useClasspathJar());
     final ProjectClassPaths cps = data.getMutationClassPaths();
 
@@ -132,6 +135,12 @@ public AnalysisResult execute(File baseDir, ReportOptions data,
 
   }
 
+  private List<String> createJvmArgs(ReportOptions data) {
+    List<String> args = new ArrayList<>(data.getJvmArgs());
+    args.addAll(ArgLineParser.split(data.getArgLine()));
+    return args;
+  }
+
   private HistoryStore makeHistoryStore(ReportOptions data,  Optional<WriterFactory> historyWriter) {
     final Optional<Reader> reader = data.createHistoryReader();
     if (!reader.isPresent() && !historyWriter.isPresent()) {

diff --git a/pitest-entry/src/main/java/org/pitest/process/ArgLineParser.java b/pitest-entry/src/main/java/org/pitest/process/ArgLineParser.java
@@ -0,0 +1,107 @@
+package org.pitest.process;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import static org.pitest.process.ArgLineParser.State.START;
+
+/**
+ * Simple state machine to split arglines into sections. Arglines may
+ * contain single or double quotes, which might be escaped.
+ */
+public class ArgLineParser {
+
+    private static final String ESCAPE_CHAR = "\\";
+    private static final String SINGLE_QUOTE = "\'";
+    public static final String DOUBLE_QUOTE = "\"";
+
+    public static List<String> split(String in) {
+        return process(stripWhiteSpace(in));
+    }
+
+    private static List<String> process(String in) {
+        if (in.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        final StringTokenizer tokenizer = new StringTokenizer(in, "\"\' \\", true);
+        List<String> tokens = new ArrayList<>();
+
+        Deque<State> state = new ArrayDeque<>();
+        state.push(START);
+        StringBuilder current = new StringBuilder();
+        while (tokenizer.hasMoreTokens()) {
+            String token = tokenizer.nextToken();
+            switch (state.peek()) {
+                case START:
+                    if (token.equals(SINGLE_QUOTE)) {
+                        state.push(State.IN_QUOTE);
+                    } else if (token.equals(DOUBLE_QUOTE)) {
+                        state.push(State.IN_DOUBLE_QUOTE);
+                    } else if (token.equals(" ")) {
+                        if (current.length() != 0) {
+                            tokens.add(current.toString());
+                            current = new StringBuilder();
+                        }
+                    } else {
+                        current.append(token);
+                        if (token.equals(ESCAPE_CHAR)) {
+                            state.push(State.IN_ESCAPE);
+                        }
+                    }
+                    break;
+                case IN_QUOTE:
+                    if (token.equals(SINGLE_QUOTE)) {
+                        state.pop();
+                    } else {
+                        current.append(token);
+                        if (token.equals(ESCAPE_CHAR)) {
+                            state.push(State.IN_ESCAPE);
+                        }
+                    }
+                    break;
+                case IN_DOUBLE_QUOTE:
+                    if (token.equals(DOUBLE_QUOTE)) {
+                        state.pop();
+                    } else {
+                        current.append(token);
+                        if (token.equals(ESCAPE_CHAR)) {
+                            state.push(State.IN_ESCAPE);
+                        }
+                    }
+                    break;
+                case IN_ESCAPE:
+                    current.append(token);
+                    if (!token.equals(ESCAPE_CHAR)) {
+                        state.pop();
+                    }
+                    break;
+            }
+        }
+
+        if (current.length() != 0) {
+            tokens.add(current.toString());
+        }
+
+        if (state.size() != 1) {
+            throw new RuntimeException("Unclosed quote in " + in);
+        }
+
+        return tokens;
+    }
+
+    private static String stripWhiteSpace(String in) {
+        if (in == null) {
+            return "";
+        }
+        return in.replaceAll("\\s", " ").trim();
+    }
+
+    enum State {
+        START, IN_ESCAPE, IN_QUOTE, IN_DOUBLE_QUOTE
+    }
+}
diff --git a/pitest-entry/src/main/java/org/pitest/process/LaunchOptions.java b/pitest-entry/src/main/java/org/pitest/process/LaunchOptions.java
@@ -33,14 +33,17 @@ public LaunchOptions(JavaAgent javaAgentFinder) {
   }
 
   public LaunchOptions(JavaAgent javaAgentFinder,
-      JavaExecutableLocator javaExecutable, List<String> childJVMArgs,
-      Map<String, String> environmentVariables) {
+                       JavaExecutableLocator javaExecutable,
+                       List<String> childJVMArgs,
+                       Map<String, String> environmentVariables) {
     this(javaAgentFinder, javaExecutable, childJVMArgs, environmentVariables, false);
   }
 
   public LaunchOptions(JavaAgent javaAgentFinder,
-      JavaExecutableLocator javaExecutable, List<String> childJVMArgs,
-      Map<String, String> environmentVariables, boolean usingClassPathJar) {
+                       JavaExecutableLocator javaExecutable,
+                       List<String> childJVMArgs,
+                       Map<String, String> environmentVariables,
+                       boolean usingClassPathJar) {
     this.javaAgentFinder = javaAgentFinder;
     this.childJVMArgs = childJVMArgs;
     this.javaExecutable = javaExecutable;

diff --git a/pitest-entry/src/main/java/org/pitest/process/WrappingProcess.java b/pitest-entry/src/main/java/org/pitest/process/WrappingProcess.java
@@ -1,7 +1,6 @@
 package org.pitest.process;
 
 import static org.pitest.functional.prelude.Prelude.or;
-
 import java.io.File;
 import java.io.IOException;
 import java.lang.management.ManagementFactory;
@@ -34,7 +33,8 @@ public void start() throws IOException {
     final String[] args = { "" + this.port };
 
     final ProcessBuilder processBuilder = createProcessBuilder(
-        this.processArgs.getJavaExecutable(), this.processArgs.getJvmArgs(),
+        this.processArgs.getJavaExecutable(),
+            this.processArgs.getJvmArgs(),
         this.minionClass, Arrays.asList(args),
         this.processArgs.getJavaAgentFinder(),
         this.processArgs.getLaunchClassPath());
@@ -109,6 +109,7 @@ private List<String> createLaunchArgs(String javaProcess,
     cmd.addAll(args);
 
     addPITJavaAgent(agentJarLocator, cmd);
+
     addLaunchJavaAgents(cmd);
 
     cmd.add(mainClass.getName());

diff --git a/pitest-entry/src/test/java/org/pitest/mutationtest/ReportTestBase.java b/pitest-entry/src/test/java/org/pitest/mutationtest/ReportTestBase.java
@@ -106,7 +106,7 @@ protected void createAndRun(SettingsFactory settings) {
       final CoverageOptions coverageOptions = createCoverageOptions(settings.createCoverageOptions().getPitConfig());
       final LaunchOptions launchOptions = new LaunchOptions(agent,
           new DefaultJavaExecutableLocator(), this.data.getJvmArgs(),
-          new HashMap<String, String>());
+          new HashMap<>());
 
       final PathFilter pf = new PathFilter(p -> true, p -> true);
       final ProjectClassPaths cps = new ProjectClassPaths(

diff --git a/pitest-entry/src/test/java/org/pitest/mutationtest/TestMutationTesting.java b/pitest-entry/src/test/java/org/pitest/mutationtest/TestMutationTesting.java
@@ -232,12 +232,11 @@ private void createEngineAndRun(final ReportOptions data,
       final JavaAgent agent,
       final Collection<String> mutators) {
 
-    // data.setConfiguration(this.config);
     final CoverageOptions coverageOptions = createCoverageOptions(data);
 
     final LaunchOptions launchOptions = new LaunchOptions(agent,
         new DefaultJavaExecutableLocator(), data.getJvmArgs(),
-        new HashMap<String, String>());
+        new HashMap<>());
 
     final PathFilter pf = new PathFilter(
         Prelude.not(new DefaultDependencyPathPredicate()),