remove classpath jar functionality

pitest-command-line/src/main/java/org/pitest/mutationtest/commandline/OptionsParser.java

@@ -148,8 +148,12 @@ public class OptionsParser {
   private final ArgumentAcceptingOptionSpec<Boolean> exportLineCoverageSpec;
   private final OptionSpec<String>                   javaExecutable;
   private final OptionSpec<KeyValuePair>             pluginPropertiesSpec;
+
+  // unused but temporarily retained
   private final OptionSpec<String>                   testPluginSpec;
   private final ArgumentAcceptingOptionSpec<Boolean> includeLaunchClasspathSpec;
+
+  // unused but temporarily retained
   private final ArgumentAcceptingOptionSpec<Boolean> useClasspathJarSpec;
   private final OptionSpec<File>                     projectBaseSpec;
   private final OptionSpec<String>                   inputEncoding;
@@ -463,8 +467,6 @@ private ParseResult parseCommandLine(final ReportOptions data,
 
     data.setIncludeLaunchClasspath(booleanValue(includeLaunchClasspathSpec, userArgs));
 
-    data.setUseClasspathJar(booleanValue(useClasspathJarSpec, userArgs));
-
     data.setShouldCreateTimestampedReports(booleanValue(timestampedReportsSpec, userArgs));
 
     data.setNumberOfThreads(this.threadsSpec.value(userArgs));
@@ -559,7 +561,7 @@ private void setClassPath(final OptionSet userArgs, final ReportOptions data) {
         LOG.warning("Unable to read class path file:" + this.classPathFile.value(userArgs).getAbsolutePath() + " - "
                 + ioe.getMessage());
       }
-      data.setUseClasspathJar(true);
+
     }
     elements.addAll(this.additionalClassPathSpec.values(userArgs));
     data.setClassPathElements(elements);

pitest-command-line/src/test/java/org/pitest/mutationtest/commandline/OptionsParserTest.java

@@ -350,14 +350,6 @@ public void shouldAcceptFileWithListOfAdditionalClassPathElements() {
     assertTrue(actual.contains("/etc/bar"));
   }
 
-  @Test
-  public void alsoSetsUseClasspathJarWhenClasspathFileProvided() {
-    final ClassLoader classLoader = getClass().getClassLoader();
-    final File classPathFile = new File(classLoader.getResource("testClassPathFile.txt").getFile());
-    final ReportOptions ro = parseAddingRequiredArgs("--classPathFile",
-            classPathFile.getAbsolutePath());
-    assertThat(ro.useClasspathJar()).isTrue();
-  }
 
   @Test
   public void shouldFailWhenNoMutationsSetByDefault() {
@@ -621,28 +613,10 @@ public void shouldIncludePluginPropertyValuesWhenMultipleKeys() {
     assertEquals("2", actual.getFreeFormProperties().getProperty("bar"));
   }
 
-  @Test
-  public void shouldDefaultToNotUsingAClasspathJar() {
-    final ReportOptions actual = parseAddingRequiredArgs();
-    assertFalse(actual.useClasspathJar());
-  }
-
-  @Test
-  public void shouldUseClasspathJarWhenFlagSet() {
-    final ReportOptions actual = parseAddingRequiredArgs("--useClasspathJar");
-    assertTrue(actual.useClasspathJar());
-  }
-
-  @Test
-  public void shouldUseClasspathJarWhenTrueSupplied() {
-    final ReportOptions actual = parseAddingRequiredArgs("--useClasspathJar=true");
-    assertTrue(actual.useClasspathJar());
-  }
 
   @Test
-  public void shouldNotUseClasspathJarWhenFalseSupplied() {
-    final ReportOptions actual = parseAddingRequiredArgs("--useClasspathJar=false");
-    assertFalse(actual.useClasspathJar());
+  public void shouldNotErrorWhenLegacyClasspathJarWhenFlagSet() {
+    assertThatCode(() -> parseAddingRequiredArgs("--useClasspathJar")).doesNotThrowAnyException();
   }
 
   @Test

pitest-entry/src/main/java/org/pitest/mutationtest/config/ReportOptions.java

@@ -145,7 +145,6 @@ public class ReportOptions {
 
   private String                         testPlugin                     = "";
 
-  private boolean                        useClasspathJar;
 
   private Path                           projectBase;
   private Charset inputEncoding;
@@ -625,14 +624,6 @@ public TestPluginArguments createMinionSettings() {
             this.getIncludedTestMethods(), this.skipFailingTests());
   }
 
-  public boolean useClasspathJar() {
-    return useClasspathJar;
-  }
-
-  public void setUseClasspathJar(boolean useClasspathJar) {
-    this.useClasspathJar = useClasspathJar;
-  }
-
   public Path getProjectBase() {
     return projectBase;
   }
@@ -729,7 +720,6 @@ public String toString() {
             .add("excludedRunners=" + excludedRunners)
             .add("includedTestMethods=" + includedTestMethods)
             .add("testPlugin='" + testPlugin + "'")
-            .add("useClasspathJar=" + useClasspathJar)
             .add("projectBase=" + projectBase)
             .add("inputEncoding=" + inputEncoding)
             .add("outputEncoding=" + outputEncoding)

pitest-entry/src/main/java/org/pitest/mutationtest/tooling/EntryPoint.java

@@ -109,8 +109,7 @@ public AnalysisResult execute(File baseDir, ReportOptions data,
 
     final CoverageOptions coverageOptions = settings.createCoverageOptions();
     final LaunchOptions launchOptions = new LaunchOptions(ja,
-        settings.getJavaExecutable(), createJvmArgs(data), environmentVariables)
-        .usingClassPathJar(data.useClasspathJar());
+        settings.getJavaExecutable(), createJvmArgs(data), environmentVariables);
 
     final ProjectClassPaths cps = data.getMutationClassPaths();
 

pitest-entry/src/main/java/org/pitest/process/Java9Process.java

@@ -26,6 +26,10 @@ public class Java9Process implements WrappingProcess {
     private final Class<?>    minionClass;
     private JavaProcess       process;
 
+    private final long pid = ProcessHandle.current().pid();
+
+    private static int       counter = 0;
+
     public Java9Process(int port, ProcessArgs args, Class<?> minionClass) {
         this.port = port;
         this.processArgs = args;
@@ -67,6 +71,10 @@ public void destroy() {
         this.process.destroy();
     }
 
+    public JavaProcess getProcess() {
+        return this.process;
+    }
+
     private ProcessBuilder createProcessBuilder(String javaProc,
                                                 List<String> args, Class<?> mainClass, List<String> programArgs,
                                                 JavaAgent javaAgent, String classPath) {
@@ -116,7 +124,13 @@ private List<String> createLaunchArgs(JavaAgent agentJarLocator, List<String> ar
     }
 
     private Path createArgsFile(List<String> cmd) throws IOException {
-        Path args = Files.createTempFile("pitest-args", ".args");
+        // To avoid conflicts with running analysis, we use the PID as part of the file name
+        // To prevent conflicts between multiple threads counter is used
+        // All files should be deleted on process exit, although some garbage may be left
+        // if the process is killed. Files are however created in the system temp directory
+        // so should be cleaned up on reboot
+        String name = "pitest-args-" + pid + "-" + nextCounter();
+        Path args = Files.createTempFile(name, ".args");
         args.toFile().deleteOnExit();
         Files.write(args, cmd);
         return args;
@@ -143,7 +157,8 @@ private static Predicate<String> isJavaAgentParam() {
         return a -> a.toLowerCase().startsWith("-javaagent");
     }
 
-    public JavaProcess getProcess() {
-        return this.process;
+    private static synchronized int nextCounter() {
+        return counter++;
     }
+
 }

pitest-entry/src/main/java/org/pitest/process/LaunchOptions.java

@@ -25,30 +25,20 @@ public class LaunchOptions {
   private final List<String>          childJVMArgs;
   private final JavaExecutableLocator javaExecutable;
   private final Map<String, String>   environmentVariables;
-  private final boolean               usingClassPathJar;
 
   public LaunchOptions(JavaAgent javaAgentFinder) {
     this(javaAgentFinder, new DefaultJavaExecutableLocator(), Collections
         .emptyList(), new HashMap<>());
   }
-
-  public LaunchOptions(JavaAgent javaAgentFinder,
-                       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) {
+                       Map<String, String> environmentVariables) {
     this.javaAgentFinder = javaAgentFinder;
     this.childJVMArgs = childJVMArgs;
     this.javaExecutable = javaExecutable;
     this.environmentVariables = environmentVariables;
-    this.usingClassPathJar = usingClassPathJar;
   }
 
   public JavaAgent getJavaAgentFinder() {
@@ -67,11 +57,4 @@ public Map<String, String> getEnvironmentVariables() {
     return this.environmentVariables;
   }
 
-  public LaunchOptions usingClassPathJar(boolean useJar) {
-    return new LaunchOptions(javaAgentFinder, javaExecutable, childJVMArgs, environmentVariables, useJar);
-  }
-
-  public boolean useClasspathJar() {
-    return usingClassPathJar;
-  }
 }

pitest-entry/src/main/java/org/pitest/process/ProcessArgs.java

@@ -35,7 +35,6 @@ public final class ProcessArgs {
   private File                workingDir = null;
   private String              javaExecutable;
   private Map<String, String> environmentVariables;
-  private boolean             useClasspathJar = false;
 
   private ProcessArgs(final String launchClassPath) {
     this.launchClassPath = launchClassPath;
@@ -92,16 +91,12 @@ public String getJavaExecutable() {
     return this.javaExecutable;
   }
 
-  public boolean useClasspathJar() {
-    return useClasspathJar;
-  }
-
+
   public ProcessArgs andLaunchOptions(final LaunchOptions launchOptions) {
     this.jvmArgs = launchOptions.getChildJVMArgs();
     this.javaAgentFinder = launchOptions.getJavaAgentFinder();
     this.javaExecutable = launchOptions.getJavaExecutable();
     this.environmentVariables = launchOptions.getEnvironmentVariables();
-    this.useClasspathJar = launchOptions.useClasspathJar();
     return this;
   }
 

pitest-maven/src/main/java/org/pitest/maven/MojoToReportOptionsConverter.java

@@ -209,7 +209,6 @@ private ReportOptions parseReportOptions(final List<String> classPath) {
       data.setCodePaths(codePaths);
     }
 
-    data.setUseClasspathJar(this.mojo.isUseClasspathJar());
     data.setClassPathElements(classPath);
 
     data.setFailWhenNoMutations(shouldFailWhenNoMutations());

pitest-maven/src/main/java/org/pitest/maven/PitMojo.java

@@ -423,9 +423,7 @@ public final class PitMojo extends AbstractMojo {
 
 
   /**
-   * Communicate the classpath using a temporary jar with a classpath
-   * manifest. This allows support of very large classpaths but may cause
-   * issues with certain libraries.
+   * Unused since 1.18.0. Temporarily left in place
    */
   @Parameter(property = "useClasspathJar", defaultValue = "false")
   private boolean                     useClasspathJar;
@@ -824,10 +822,6 @@ public ArrayList<String> getFeatures() {
     return consolidated;
   }
 
-  public boolean isUseClasspathJar() {
-    return this.useClasspathJar;
-  }
-
   public String getVerbosity() {
     return verbosity;
   }

pitest-maven/src/test/java/org/pitest/maven/MojoToReportOptionsConverterTest.java

@@ -416,14 +416,11 @@ public void testParsesCustomProperties() {
     assertEquals("bar", actual.getFreeFormProperties().get("bar"));
   }
 
-  public void testDoesNotUseClasspathJarByDefault() {
-    final ReportOptions actual = parseConfig("");
-    assertFalse(actual.useClasspathJar());
-  }  
-
-  public void testParsesUseClasspathJar() {
-    final ReportOptions actual = parseConfig("<useClasspathJar>true</useClasspathJar>");
-    assertTrue(actual.useClasspathJar());
+
+  public void testLegacyClasspathJarParamDoesNotCauseError() {
+    assertThatCode(() -> parseConfig("<useClasspathJar>true</useClasspathJar>"))
+            .doesNotThrowAnyException();
+
   }
 
   public void testFailsIfObsoleteMaxMutationsParameterUsed() {