From 650641c6dcb0f9b026df196d4756d5d8d43041b9 Mon Sep 17 00:00:00 2001
From: "Erik C. Thauvin" <erik@thauvin.net>
Date: Sat, 3 May 2025 22:35:30 -0700
Subject: [PATCH] Cleanup tests

---
 .idea/misc.xml                                |    2 +-
 .../bld/extension/PitestOperationTest.java    | 1642 +++++++++--------
 2 files changed, 850 insertions(+), 794 deletions(-)

diff --git a/.idea/misc.xml b/.idea/misc.xml
index 192c134..421b052 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -20,7 +20,7 @@
     </option>
     <option name="skipTestSources" value="false" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build" />
   </component>
 </project>
\ No newline at end of file
diff --git a/src/test/java/rife/bld/extension/PitestOperationTest.java b/src/test/java/rife/bld/extension/PitestOperationTest.java
index bb5ed8c..9cf0e3d 100644
--- a/src/test/java/rife/bld/extension/PitestOperationTest.java
+++ b/src/test/java/rife/bld/extension/PitestOperationTest.java
@@ -17,6 +17,8 @@
 package rife.bld.extension;
 
 import org.assertj.core.api.AutoCloseableSoftAssertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.condition.EnabledOnOs;
 import org.junit.jupiter.api.condition.OS;
@@ -37,812 +39,866 @@ import static org.assertj.core.api.Assertions.assertThatCode;
 import static rife.bld.extension.PitestOperation.FALSE;
 import static rife.bld.extension.PitestOperation.TRUE;
 
-@SuppressWarnings("PMD.AvoidDuplicateLiterals")
 class PitestOperationTest {
-    private static final String AS_LIST = "as list";
     private static final String BAR = "bar";
+    private static final File BAR_FILE = new File(BAR);
     private static final String FOO = "foo";
     private static final String FOOBAR = FOO + ',' + BAR;
+    private static final File FOO_FILE = new File(FOO);
+    private static final String FOOBAR_FORMAT =
+            String.format("%s,%s", FOO_FILE.getAbsolutePath(), BAR_FILE.getAbsolutePath());
 
-    @Test
-    void argLine() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .argLine(FOO);
-        assertThat(op.options().get("--argLine")).isEqualTo(FOO);
-    }
+    @Nested
+    @DisplayName("Execute Tests")
+    class ExecuteTests {
 
-    @Test
-    void avoidCallsTo() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .avoidCallsTo(FOO, BAR);
-        assertThat(op.options().get("--avoidCallsTo")).isEqualTo(FOOBAR);
+        @Test
+        void execute() throws IOException {
+            var tmpDir = Files.createTempDirectory("bld-pitest-");
+            tmpDir.toFile().deleteOnExit();
+            var op = new PitestOperation().
+                    fromProject(new WebProject())
+                    .reportDir(tmpDir.toAbsolutePath().toString())
+                    .targetClasses("com.example.*")
+                    .targetTests("com.example.*")
+                    .verbose(true)
+                    .failWhenNoMutations(false)
+                    .sourceDirs("examples/src");
 
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .avoidCallsTo(List.of(FOO, BAR));
-        assertThat(op.options().get("--avoidCallsTo")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
+            assertThatCode(op::execute).doesNotThrowAnyException();
+            assertThat(tmpDir).isEmptyDirectory();
+        }
 
-    @Test
-    @EnabledOnOs(OS.LINUX)
-    void checkAllParameters() throws IOException {
-        var args = Files.readAllLines(Paths.get("src", "test", "resources", "pitest-args.txt"));
+        @Test
+        void executeConstructProcessCommandList() {
+            var op = new PitestOperation().
+                    fromProject(new WebProject())
+                    .reportDir("outputdir")
+                    .targetClasses("com.your.package.tobemutated*")
+                    .targetTests("com.your.package.*")
+                    .sourceDirs("parthsource");
 
-        assertThat(args).isNotEmpty();
+            assertThat(String.join(" ", op.executeConstructProcessCommandList())).endsWith(
+                    " org.pitest.mutationtest.commandline.MutationCoverageReport " +
+                            "--targetTests com.your.package.* " +
+                            "--reportDir outputdir " +
+                            "--targetClasses com.your.package.tobemutated* " +
+                            "--sourceDirs parthsource");
 
-        var params = new PitestOperation()
-                .fromProject(new BaseProject())
-                .argLine(FOO)
-                .avoidCallsTo(FOO, BAR)
-                .classPath(FOO, BAR)
-                .classPathFile(FOO)
-                .coverageThreshold(0)
-                .detectInlinedCode(false)
-                .dryRun(false)
-                .excludedClasses("class")
-                .excludedClasses(List.of(FOO, BAR))
-                .excludedGroups("group")
-                .excludedGroups(List.of(FOO, BAR))
-                .excludedMethods("method")
-                .excludedMethods(List.of(FOO, BAR))
-                .excludedRunners("runners")
-                .excludedTestClasses("test")
-                .exportLineCoverage(true)
-                .failWhenNoMutations(true)
-                .features("feature")
-                .fullMutationMatrix(true)
-                .historyInputLocation("inputLocation")
-                .historyOutputLocation("outputLocation")
-                .includeLaunchClasspath(true)
-                .includedGroups("group")
-                .includedTestMethods("method")
-                .inputEncoding("encoding")
-                .jvmArgs("-XX:+UnlogregckDiagnosticVMOptions")
-                .jvmPath("path")
-                .maxMutationsPerClass(3)
-                .maxSurviving(1)
-                .mutableCodePaths("codePaths")
-                .mutationEngine("engine")
-                .mutationThreshold(0)
-                .mutationUnitSize(1)
-                .mutators(List.of(FOO, BAR))
-                .outputEncoding("encoding")
-                .outputFormats("json")
-                .pluginConfiguration("key", "value")
-                .projectBase("base")
-                .reportDir("dir")
-                .skipFailingTests(true)
-                .targetClasses("class")
-                .targetTests("test")
-                .testStrengthThreshold(0)
-                .threads(0)
-                .timeoutConst(0)
-                .timeoutFactor(0)
-                .timestampedReports(true)
-                .useClasspathJar(true)
-                .verbose(true)
-                .verbosity("default")
-                .executeConstructProcessCommandList();
+            op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .reportDir("c:\\mutationReports")
+                    .targetClasses("example.foo.*")
+                    .sourceDirs("c:\\myProject\\src")
+                    .targetTests("example.foo*")
+                    .threads(2)
+                    .excludedMethods("hashcode", "equals");
+            assertThat(String.join(" ", op.executeConstructProcessCommandList())).endsWith(
+                    "org.pitest.mutationtest.commandline.MutationCoverageReport " +
+                            "--targetTests example.foo* " +
+                            "--threads 2 " +
+                            "--excludedMethods hashcode,equals " +
+                            "--reportDir c:\\mutationReports " +
+                            "--targetClasses example.foo.* " +
+                            "--sourceDirs c:\\myProject\\src");
+        }
 
-        try (var softly = new AutoCloseableSoftAssertions()) {
-            for (var p : args) {
-                var found = false;
-                for (var a : params) {
-                    if (a.startsWith(p)) {
-                        found = true;
-                        break;
-                    }
-                }
-                softly.assertThat(found).as(p + " not found.").isTrue();
-            }
+        @Test
+        void executeNoProject() {
+            var op = new PitestOperation();
+            assertThatCode(op::execute).isInstanceOf(ExitStatusException.class);
+        }
+
+        @Test
+        void exportLineCoverage() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .exportLineCoverage(true);
+            assertThat(op.options().get("--exportLineCoverage")).isEqualTo(TRUE);
+
+            op = new PitestOperation()
+                    .fromProject(new Project())
+                    .exportLineCoverage(false);
+            assertThat(op.options().get("--exportLineCoverage")).isEqualTo(FALSE);
         }
     }
 
-    @Test
-    void classPath() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .classPath(FOO, BAR);
-        assertThat(op.options().get("--classPath")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .classPath(List.of(FOO, BAR));
-        assertThat(op.options().get("--classPath")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void classPathFile() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .classPathFile(FOO);
-        assertThat(op.options().get("--classPathFile")).isEqualTo(FOO);
-    }
-
-    @Test
-    void coverageThreshold() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .coverageThreshold(3);
-        assertThat(op.options().get("--coverageThreshold")).isEqualTo("3");
-
-        op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .coverageThreshold(101);
-        assertThat(op.options().get("--coverageThreshold")).isNull();
-    }
-
-    @Test
-    void detectInlinedCode() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .detectInlinedCode(true);
-        assertThat(op.options().get("--detectInlinedCode")).isEqualTo(TRUE);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .detectInlinedCode(false);
-        assertThat(op.options().get("--detectInlinedCode")).isEqualTo(FALSE);
-    }
-
-    @Test
-    void excludedClasses() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .excludedClasses(FOO, BAR);
-        assertThat(op.options().get("--excludedClasses")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .excludedClasses(Set.of(FOO, BAR));
-        assertThat(op.options().get("--excludedClasses")).as("as set").contains(FOO).contains(BAR).contains(",");
-    }
-
-    @Test
-    void excludedGroups() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .excludedGroups(FOO, BAR);
-        assertThat(op.options().get("--excludedGroups")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .excludedGroups(List.of(FOO, BAR));
-        assertThat(op.options().get("--excludedGroups")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void excludedMethods() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .excludedMethods(FOO, BAR);
-        assertThat(op.options().get("--excludedMethods")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .excludedMethods(List.of(FOO, BAR));
-        assertThat(op.options().get("--excludedMethods")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void excludedRunners() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .excludedRunners(FOO);
-        assertThat(op.options().get("--excludedRunners")).isEqualTo(FOO);
-    }
-
-    @Test
-    void excludedTests() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .excludedTestClasses(FOO, BAR);
-        assertThat(op.options().get("--excludedTestClasses")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .excludedTestClasses(List.of(FOO, BAR));
-        assertThat(op.options().get("--excludedTestClasses")).as("as list").isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void execute() throws IOException {
-        var tmpDir = Files.createTempDirectory("bld-pitest-");
-        tmpDir.toFile().deleteOnExit();
-        var op = new PitestOperation().
-                fromProject(new WebProject())
-                .reportDir(tmpDir.toAbsolutePath().toString())
-                .targetClasses("com.example.*")
-                .targetTests("com.example.*")
-                .verbose(true)
-                .failWhenNoMutations(false)
-                .sourceDirs("examples/src");
-
-        assertThatCode(op::execute).doesNotThrowAnyException();
-        assertThat(tmpDir).isEmptyDirectory();
-    }
-
-    @Test
-    void executeConstructProcessCommandList() {
-        var op = new PitestOperation().
-                fromProject(new WebProject())
-                .reportDir("outputdir")
-                .targetClasses("com.your.package.tobemutated*")
-                .targetTests("com.your.package.*")
-                .sourceDirs("parthsource");
-
-        assertThat(String.join(" ", op.executeConstructProcessCommandList())).endsWith(
-                " org.pitest.mutationtest.commandline.MutationCoverageReport " +
-                        "--targetTests com.your.package.* " +
-                        "--reportDir outputdir " +
-                        "--targetClasses com.your.package.tobemutated* " +
-                        "--sourceDirs parthsource");
-
-        op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .reportDir("c:\\mutationReports")
-                .targetClasses("example.foo.*")
-                .sourceDirs("c:\\myProject\\src")
-                .targetTests("example.foo*")
-                .threads(2)
-                .excludedMethods("hashcode", "equals");
-        assertThat(String.join(" ", op.executeConstructProcessCommandList())).as("mutationReports").endsWith(
-                "org.pitest.mutationtest.commandline.MutationCoverageReport " +
-                        "--targetTests example.foo* " +
-                        "--threads 2 " +
-                        "--excludedMethods hashcode,equals " +
-                        "--reportDir c:\\mutationReports " +
-                        "--targetClasses example.foo.* " +
-                        "--sourceDirs c:\\myProject\\src");
-    }
-
-    @Test
-    void executeNoProject() {
-        var op = new PitestOperation();
-        assertThatCode(op::execute).isInstanceOf(ExitStatusException.class);
-    }
-
-    @Test
-    void exportLineCoverage() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .exportLineCoverage(true);
-        assertThat(op.options().get("--exportLineCoverage")).isEqualTo(TRUE);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .exportLineCoverage(false);
-        assertThat(op.options().get("--exportLineCoverage")).isEqualTo(FALSE);
-    }
-
-    @Test
-    void failWhenNoMutations() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .failWhenNoMutations(true);
-        assertThat(op.options().get("--failWhenNoMutations")).isEqualTo(TRUE);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .failWhenNoMutations(false);
-        assertThat(op.options().get("--failWhenNoMutations")).isEqualTo(FALSE);
-    }
-
-    @Test
-    void features() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .features(FOO, BAR);
-        assertThat(op.options().get("--features")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .features(List.of(FOO, BAR));
-        assertThat(op.options().get("--features")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void fullMutationMatrix() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .fullMutationMatrix(true);
-        assertThat(op.options().get("--fullMutationMatrix")).isEqualTo(TRUE);
-    }
-
-    @Test
-    void historyInputLocation() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .historyInputLocation(FOO);
-        assertThat(op.options().get("--historyInputLocation")).isEqualTo(FOO);
-    }
-
-    @Test
-    void historyOutputLocation() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .historyOutputLocation(FOO);
-        assertThat(op.options().get("--historyOutputLocation")).isEqualTo(FOO);
-    }
-
-    @Test
-    void includeLaunchClasspath() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .includeLaunchClasspath(true);
-        assertThat(op.options().get("--includeLaunchClasspath")).isEqualTo(TRUE);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .includeLaunchClasspath(false);
-        assertThat(op.options().get("--includeLaunchClasspath")).isEqualTo(FALSE);
-    }
-
-    @Test
-    void includedGroups() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .includedGroups(FOO, BAR);
-        assertThat(op.options().get("--includedGroups")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .includedGroups(List.of(FOO, BAR));
-        assertThat(op.options().get("--includedGroups")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void includedTestMethods() {
-        var op = new PitestOperation()
-                .fromProject(new Project())
-                .includedTestMethods(FOO);
-        assertThat(op.options().get("--includedTestMethods")).isEqualTo(FOO);
-    }
-
-    @Test
-    void inputEncoding() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .inputEncoding(FOO);
-        assertThat(op.options().get("--inputEncoding")).isEqualTo(FOO);
-    }
-
-    @Test
-    void jvmArgs() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .jvmArgs(FOO, BAR);
-        assertThat(op.options().get("--jvmArgs")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .jvmArgs(List.of(FOO, BAR));
-        assertThat(op.options().get("--jvmArgs")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void jvmPath() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .jvmPath(FOO);
-        assertThat(op.options().get("--jvmPath")).isEqualTo(FOO);
-    }
-
-    @Test
-    void maxMutationsPerClass() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .maxMutationsPerClass(12);
-        assertThat(op.options().get("--maxMutationsPerClass")).isEqualTo("12");
-    }
-
-    @Test
-    void maxSurviving() {
-        var op = new PitestOperation()
-                .fromProject(new Project())
-                .maxSurviving(1);
-        assertThat(op.options().get("--maxSurviving")).isEqualTo("1");
-    }
-
-    @Test
-    void mutableCodePaths() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .mutableCodePaths(FOO, BAR);
-        assertThat(op.options().get("--mutableCodePaths")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .mutableCodePaths(List.of(FOO, BAR));
-        assertThat(op.options().get("--mutableCodePaths")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void mutationEngine() {
-        var op = new PitestOperation()
-                .fromProject(new Project())
-                .mutationEngine(FOO);
-        assertThat(op.options().get("--mutationEngine")).isEqualTo(FOO);
-    }
-
-    @Test
-    void mutationThreshold() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .mutationThreshold(3);
-        assertThat(op.options().get("--mutationThreshold")).isEqualTo("3");
-
-        op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .mutationThreshold(101);
-        assertThat(op.options().get("--mutationThreshold")).isNull();
-    }
-
-    @Test
-    void mutationUnitSize() {
-        var op = new PitestOperation()
-                .fromProject(new Project())
-                .mutationUnitSize(2);
-        assertThat(op.options().get("--mutationUnitSize")).isEqualTo("2");
-    }
-
-    @Test
-    void mutators() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .mutators(FOO, BAR);
-        assertThat(op.options().get("--mutators")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .mutators(List.of(FOO, BAR));
-        assertThat(op.options().get("--mutators")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void outputEncoding() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .outputEncoding(FOO);
-        assertThat(op.options().get("--outputEncoding")).isEqualTo(FOO);
-    }
-
-    @Test
-    void outputFormats() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .outputFormats(FOO, BAR);
-        assertThat(op.options().get("--outputFormats")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .outputFormats(List.of(FOO, BAR));
-        assertThat(op.options().get("--outputFormats")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void pluginConfiguration() {
-        var op = new PitestOperation()
-                .fromProject(new Project())
-                .pluginConfiguration(FOO, BAR);
-        assertThat(op.options().get("--pluginConfiguration")).isEqualTo(FOO + "=" + BAR);
-    }
-
-    @Test
-    void projectBase() {
-        var op = new PitestOperation()
-                .fromProject(new Project())
-                .projectBase(FOO);
-        assertThat(op.options().get("--projectBase")).isEqualTo(FOO);
-    }
-
-    @Test
-    void reportDir() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .reportDir(FOO);
-        assertThat(op.options().get("--reportDir")).isEqualTo(FOO);
-    }
-
-    @Test
-    void skipFailingTests() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .skipFailingTests(true);
-        assertThat(op.options().get("--skipFailingTests")).isEqualTo(TRUE);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .skipFailingTests(false);
-        assertThat(op.options().get("--skipFailingTests")).isEqualTo(FALSE);
-    }
-
-    @Test
-    void sourceDirs() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .sourceDirs(FOO, BAR);
-        assertThat(op.options().get("--sourceDirs")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .sourceDirs(List.of(FOO, BAR));
-        assertThat(op.options().get("--sourceDirs")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void targetClasses() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .targetClasses(FOO, BAR);
-        assertThat(op.options().get("--targetClasses")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .targetClasses(List.of(FOO, BAR));
-        assertThat(op.options().get("--targetClasses")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void targetTests() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .targetTests(FOO, BAR);
-        assertThat(op.options().get("--targetTests")).isEqualTo(FOOBAR);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .targetTests(List.of(FOO, BAR));
-        assertThat(op.options().get("--targetTests")).as(AS_LIST).isEqualTo(FOOBAR);
-    }
-
-    @Test
-    void testClassPath() {
-        var foo = new File(FOO);
-        var bar = new File(BAR);
-
-        var foobar = String.format("%s,%s", FOO, BAR);
-        var op = new PitestOperation().classPath(FOO, BAR);
-        assertThat(op.options().get("--classPath")).as("String...").isEqualTo(foobar);
-
-        op = new PitestOperation().classPath(List.of(FOO, BAR));
-        assertThat(op.options().get("--classPath")).as("List(String...)").isEqualTo(foobar);
-
-        foobar = String.format("%s,%s", foo.getAbsolutePath(), bar.getAbsolutePath());
-        op = new PitestOperation().classPath(foo, bar);
-        assertThat(op.options().get("--classPath")).as("File...").isEqualTo(foobar);
-
-        op = new PitestOperation().classPathFiles(List.of(foo, bar));
-        assertThat(op.options().get("--classPath")).as("List(String...)").isEqualTo(foobar);
-
-        op = new PitestOperation().classPath(foo.toPath(), bar.toPath());
-        assertThat(op.options().get("--classPath")).as("Path...").isEqualTo(foobar);
-
-        op = new PitestOperation().classPathPaths(List.of(foo.toPath(), bar.toPath()));
-        assertThat(op.options().get("--classPath")).as("List(Path...)").isEqualTo(foobar);
-    }
-
-    @Test
-    void testHistoryInputLocation() {
-        var foo = new File(FOO);
-        var op = new PitestOperation().historyInputLocation(FOO);
-        assertThat(op.options().get("--historyInputLocation")).as("as string").isEqualTo(FOO);
-
-        op = new PitestOperation().historyInputLocation(foo);
-        assertThat(op.options().get("--historyInputLocation")).as("as file").isEqualTo(foo.getAbsolutePath());
-
-        op = new PitestOperation().historyInputLocation(foo.toPath());
-        assertThat(op.options().get("--historyInputLocation")).as("as path").isEqualTo(foo.getAbsolutePath());
-    }
-
-    @Test
-    void testHistoryOutputLocation() {
-        var foo = new File(FOO);
-        var op = new PitestOperation().historyOutputLocation(FOO);
-        assertThat(op.options().get("--historyOutputLocation")).as("as string").isEqualTo(FOO);
-
-        op = new PitestOperation().historyOutputLocation(foo);
-        assertThat(op.options().get("--historyOutputLocation")).as("as file").isEqualTo(foo.getAbsolutePath());
-
-        op = new PitestOperation().historyOutputLocation(foo.toPath());
-        assertThat(op.options().get("--historyOutputLocation")).as("as path").isEqualTo(foo.getAbsolutePath());
-    }
-
-    @Test
-    void testJvmPath() {
-        var foo = new File(FOO);
-        var op = new PitestOperation().jvmPath(FOO);
-        assertThat(op.options().get("--jvmPath")).as("as string").isEqualTo(FOO);
-
-        op = new PitestOperation().jvmPath(foo);
-        assertThat(op.options().get("--jvmPath")).as("as file").isEqualTo(foo.getAbsolutePath());
-
-        op = new PitestOperation().jvmPath(foo.toPath());
-        assertThat(op.options().get("--jvmPath")).as("as path").isEqualTo(foo.getAbsolutePath());
-    }
-
-    @Test
-    void testMutableCodePaths() {
-        var foo = new File(FOO);
-        var bar = new File(BAR);
-
-        var foobar = String.format("%s,%s", FOO, BAR);
-        var op = new PitestOperation().mutableCodePaths(FOO, BAR);
-        assertThat(op.options().get("--mutableCodePaths")).as("String...").isEqualTo(foobar);
-
-        op = new PitestOperation().mutableCodePaths(List.of(FOO, BAR));
-        assertThat(op.options().get("--mutableCodePaths")).as("List(String...)").isEqualTo(foobar);
-
-        foobar = String.format("%s,%s", foo.getAbsolutePath(), bar.getAbsolutePath());
-        op = new PitestOperation().mutableCodePaths(foo, bar);
-        assertThat(op.options().get("--mutableCodePaths")).as("File...").isEqualTo(foobar);
-
-        op = new PitestOperation().mutableCodePathsFiles(List.of(foo, bar));
-        assertThat(op.options().get("--mutableCodePaths")).as("List(String...)").isEqualTo(foobar);
-
-        op = new PitestOperation().mutableCodePaths(foo.toPath(), bar.toPath());
-        assertThat(op.options().get("--mutableCodePaths")).as("Path...").isEqualTo(foobar);
-
-        op = new PitestOperation().mutableCodePathsPaths(List.of(foo.toPath(), bar.toPath()));
-        assertThat(op.options().get("--mutableCodePaths")).as("List(Path...)").isEqualTo(foobar);
-    }
-
-    @Test
-    void testOutputFormats() {
-        var foo = new File(FOO);
-        var bar = new File(BAR);
-
-        var foobar = String.format("%s,%s", FOO, BAR);
-        var op = new PitestOperation().outputFormats(FOO, BAR);
-        assertThat(op.options().get("--outputFormats")).as("String...").isEqualTo(foobar);
-
-        op = new PitestOperation().outputFormats(List.of(FOO, BAR));
-        assertThat(op.options().get("--outputFormats")).as("List(String...)").isEqualTo(foobar);
-
-        foobar = String.format("%s,%s", foo.getAbsolutePath(), bar.getAbsolutePath());
-        op = new PitestOperation().outputFormats(foo, bar);
-        assertThat(op.options().get("--outputFormats")).as("File...").isEqualTo(foobar);
-
-        op = new PitestOperation().outputFormatsFiles(List.of(foo, bar));
-        assertThat(op.options().get("--outputFormats")).as("List(String...)").isEqualTo(foobar);
-
-        op = new PitestOperation().outputFormats(foo.toPath(), bar.toPath());
-        assertThat(op.options().get("--outputFormats")).as("Path...").isEqualTo(foobar);
-
-        op = new PitestOperation().outputFormatsPaths(List.of(foo.toPath(), bar.toPath()));
-        assertThat(op.options().get("--outputFormats")).as("List(Path...)").isEqualTo(foobar);
-    }
-
-    @Test
-    void testProjectBase() {
-        var foo = new File(FOO);
-        var op = new PitestOperation().projectBase(FOO);
-        assertThat(op.options().get("--projectBase")).as("as string").isEqualTo(FOO);
-
-        op = new PitestOperation().projectBase(foo);
-        assertThat(op.options().get("--projectBase")).as("as file").isEqualTo(foo.getAbsolutePath());
-
-        op = new PitestOperation().projectBase(foo.toPath());
-        assertThat(op.options().get("--projectBase")).as("as path").isEqualTo(foo.getAbsolutePath());
-    }
-
-    @Test
-    void testReportDir() {
-        var foo = new File(FOO);
-        var op = new PitestOperation().reportDir(FOO);
-        assertThat(op.options().get("--reportDir")).as("as string").isEqualTo(FOO);
-
-        op = new PitestOperation().reportDir(foo);
-        assertThat(op.options().get("--reportDir")).as("as file").isEqualTo(foo.getAbsolutePath());
-
-        op = new PitestOperation().reportDir(foo.toPath());
-        assertThat(op.options().get("--reportDir")).as("as path").isEqualTo(foo.getAbsolutePath());
-    }
-
-    @Test
-    void testSourceDirs() {
-        var foo = new File(FOO);
-        var bar = new File(BAR);
-
-        var foobar = String.format("%s,%s", FOO, BAR);
-        var op = new PitestOperation().sourceDirs(FOO, BAR);
-        assertThat(op.options().get("--sourceDirs")).as("String...").isEqualTo(foobar);
-
-        op = new PitestOperation().sourceDirs(List.of(FOO, BAR));
-        assertThat(op.options().get("--sourceDirs")).as("List(String...)").isEqualTo(foobar);
-
-        foobar = String.format("%s,%s", foo.getAbsolutePath(), bar.getAbsolutePath());
-        op = new PitestOperation().sourceDirs(foo, bar);
-        assertThat(op.options().get("--sourceDirs")).as("File...").isEqualTo(foobar);
-
-        op = new PitestOperation().sourceDirsFiles(List.of(foo, bar));
-        assertThat(op.options().get("--sourceDirs")).as("List(String...)").isEqualTo(foobar);
-
-        op = new PitestOperation().sourceDirs(foo.toPath(), bar.toPath());
-        assertThat(op.options().get("--sourceDirs")).as("Path...").isEqualTo(foobar);
-
-        op = new PitestOperation().sourceDirsPaths(List.of(foo.toPath(), bar.toPath()));
-        assertThat(op.options().get("--sourceDirs")).as("List(Path...)").isEqualTo(foobar);
-    }
-
-    @Test
-    void testStrengthThreshold() {
-        var op = new PitestOperation()
-                .fromProject(new Project())
-                .testStrengthThreshold(6);
-        assertThat(op.options().get("--testStrengthThreshold")).isEqualTo("6");
-    }
-
-    @Test
-    void threads() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .threads(3);
-        assertThat(op.options().get("--threads")).isEqualTo("3");
-    }
-
-    @Test
-    void timeoutConst() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .timeoutConst(300);
-        assertThat(op.options().get("--timeoutConst")).isEqualTo("300");
-    }
-
-    @Test
-    void timeoutFactor() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .timeoutFactor(5.25);
-        assertThat(op.options().get("--timeoutFactor")).isEqualTo("5.25");
-    }
-
-    @Test
-    void timestampedReports() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .timestampedReports(true);
-        assertThat(op.options().get("--timestampedReports")).isEqualTo(TRUE);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .timestampedReports(false);
-        assertThat(op.options().get("--timestampedReports")).isEqualTo(FALSE);
-    }
-
-    @Test
-    void useClasspathJar() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .useClasspathJar(true);
-        assertThat(op.options().get("--useClasspathJar")).isEqualTo(TRUE);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .useClasspathJar(false);
-        assertThat(op.options().get("--useClasspathJar")).isEqualTo(FALSE);
-    }
-
-    @Test
-    void verbose() {
-        var op = new PitestOperation()
-                .fromProject(new BaseProject())
-                .verbose(true);
-        assertThat(op.options().get("--verbose")).isEqualTo(TRUE);
-
-        op = new PitestOperation()
-                .fromProject(new Project())
-                .verbose(false);
-        assertThat(op.options().get("--verbose")).isEqualTo(FALSE);
-    }
-
-    @Test
-    void verbosity() {
-        var op = new PitestOperation()
-                .fromProject(new Project())
-                .verbosity(FOO);
-        assertThat(op.options().get("--verbosity")).isEqualTo(FOO);
+    @Nested
+    @DisplayName("Options Tests")
+    class OptionsTests {
+        @Test
+        void argLine() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .argLine(FOO);
+            assertThat(op.options().get("--argLine")).isEqualTo(FOO);
+        }
+
+        @Test
+        void avoidCallsTo() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .avoidCallsTo(FOO, BAR);
+            assertThat(op.options().get("--avoidCallsTo")).isEqualTo(FOOBAR);
+
+            op = new PitestOperation()
+                    .fromProject(new Project())
+                    .avoidCallsTo(List.of(FOO, BAR));
+            assertThat(op.options().get("--avoidCallsTo")).isEqualTo(FOOBAR);
+        }
+
+        @Test
+        @EnabledOnOs(OS.LINUX)
+        void checkAllParameters() throws IOException {
+            var args = Files.readAllLines(Paths.get("src", "test", "resources", "pitest-args.txt"));
+
+            assertThat(args).isNotEmpty();
+
+            var params = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .argLine(FOO)
+                    .avoidCallsTo(FOO, BAR)
+                    .classPath(FOO, BAR)
+                    .classPathFile(FOO)
+                    .coverageThreshold(0)
+                    .detectInlinedCode(false)
+                    .dryRun(false)
+                    .excludedClasses("class")
+                    .excludedClasses(List.of(FOO, BAR))
+                    .excludedGroups("group")
+                    .excludedGroups(List.of(FOO, BAR))
+                    .excludedMethods("method")
+                    .excludedMethods(List.of(FOO, BAR))
+                    .excludedRunners("runners")
+                    .excludedTestClasses("test")
+                    .exportLineCoverage(true)
+                    .failWhenNoMutations(true)
+                    .features("feature")
+                    .fullMutationMatrix(true)
+                    .historyInputLocation("inputLocation")
+                    .historyOutputLocation("outputLocation")
+                    .includeLaunchClasspath(true)
+                    .includedGroups("group")
+                    .includedTestMethods("method")
+                    .inputEncoding("encoding")
+                    .jvmArgs("-XX:+UnlogregckDiagnosticVMOptions")
+                    .jvmPath("path")
+                    .maxMutationsPerClass(3)
+                    .maxSurviving(1)
+                    .mutableCodePaths("codePaths")
+                    .mutationEngine("engine")
+                    .mutationThreshold(0)
+                    .mutationUnitSize(1)
+                    .mutators(List.of(FOO, BAR))
+                    .outputEncoding("encoding")
+                    .outputFormats("json")
+                    .pluginConfiguration("key", "value")
+                    .projectBase("base")
+                    .reportDir("dir")
+                    .skipFailingTests(true)
+                    .targetClasses("class")
+                    .targetTests("test")
+                    .testStrengthThreshold(0)
+                    .threads(0)
+                    .timeoutConst(0)
+                    .timeoutFactor(0)
+                    .timestampedReports(true)
+                    .useClasspathJar(true)
+                    .verbose(true)
+                    .verbosity("default")
+                    .executeConstructProcessCommandList();
+
+            try (var softly = new AutoCloseableSoftAssertions()) {
+                for (var p : args) {
+                    var found = false;
+                    for (var a : params) {
+                        if (a.startsWith(p)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    softly.assertThat(found).as("%s not found", p).isTrue();
+                }
+            }
+        }
+
+        @Test
+        void coverageThreshold() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .coverageThreshold(3);
+            assertThat(op.options().get("--coverageThreshold")).isEqualTo("3");
+
+            op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .coverageThreshold(101);
+            assertThat(op.options().get("--coverageThreshold")).isNull();
+        }
+
+        @Test
+        void detectInlinedCode() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .detectInlinedCode(true);
+            assertThat(op.options().get("--detectInlinedCode")).isEqualTo(TRUE);
+
+            op = new PitestOperation()
+                    .fromProject(new Project())
+                    .detectInlinedCode(false);
+            assertThat(op.options().get("--detectInlinedCode")).isEqualTo(FALSE);
+        }
+
+        @Test
+        void features() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .features(FOO, BAR);
+            assertThat(op.options().get("--features")).isEqualTo(FOOBAR);
+
+            op = new PitestOperation()
+                    .fromProject(new Project())
+                    .features(List.of(FOO, BAR));
+            assertThat(op.options().get("--features")).isEqualTo(FOOBAR);
+        }
+
+
+        @Test
+        void inputEncoding() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .inputEncoding(FOO);
+            assertThat(op.options().get("--inputEncoding")).isEqualTo(FOO);
+        }
+
+        @Test
+        void maxSurviving() {
+            var op = new PitestOperation()
+                    .fromProject(new Project())
+                    .maxSurviving(1);
+            assertThat(op.options().get("--maxSurviving")).isEqualTo("1");
+        }
+
+        @Test
+        void pluginConfiguration() {
+            var op = new PitestOperation()
+                    .fromProject(new Project())
+                    .pluginConfiguration(FOO, BAR);
+            assertThat(op.options().get("--pluginConfiguration")).isEqualTo(FOO + "=" + BAR);
+        }
+
+        @Test
+        void projectBase() {
+            var op = new PitestOperation().projectBase(FOO);
+            var key = "--projectBase";
+
+            assertThat(op.options().get(key)).isEqualTo(FOO);
+
+            op = new PitestOperation().projectBase(FOO_FILE);
+            assertThat(op.options().get(key)).isEqualTo(FOO_FILE.getAbsolutePath());
+
+            op = new PitestOperation().projectBase(FOO_FILE.toPath());
+            assertThat(op.options().get(key)).isEqualTo(FOO_FILE.getAbsolutePath());
+        }
+
+        @Test
+        void skipFailingTests() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .skipFailingTests(true);
+            assertThat(op.options().get("--skipFailingTests")).isEqualTo(TRUE);
+
+            op = new PitestOperation()
+                    .fromProject(new Project())
+                    .skipFailingTests(false);
+            assertThat(op.options().get("--skipFailingTests")).isEqualTo(FALSE);
+        }
+
+        @Test
+        void strengthThreshold() {
+            var op = new PitestOperation()
+                    .fromProject(new Project())
+                    .testStrengthThreshold(6);
+            assertThat(op.options().get("--testStrengthThreshold")).isEqualTo("6");
+        }
+
+        @Test
+        void threads() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .threads(3);
+            assertThat(op.options().get("--threads")).isEqualTo("3");
+        }
+
+        @Test
+        void timestampedReports() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .timestampedReports(true);
+            assertThat(op.options().get("--timestampedReports")).isEqualTo(TRUE);
+
+            op = new PitestOperation()
+                    .fromProject(new Project())
+                    .timestampedReports(false);
+            assertThat(op.options().get("--timestampedReports")).isEqualTo(FALSE);
+        }
+
+        @Nested
+        @DisplayName("ClassPath Tests")
+        class ClassPathTests {
+            private static final String CLASS_PATH = "--classPath";
+
+            @Test
+            void classPathAsFile() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .classPathFile(FOO);
+                assertThat(op.options().get("--classPathFile")).isEqualTo(FOO);
+            }
+
+            @Test
+            void classPathAsFileArray() {
+                var op = new PitestOperation().classPath(FOO_FILE, BAR_FILE);
+                assertThat(op.options().get(CLASS_PATH)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void classPathAsFileList() {
+                var op = new PitestOperation().classPathFiles(List.of(FOO_FILE, BAR_FILE));
+                assertThat(op.options().get(CLASS_PATH)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void classPathAsList() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .classPath(List.of(FOO, BAR));
+                assertThat(op.options().get(CLASS_PATH)).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void classPathAsStringArray() {
+                var op = new PitestOperation().classPath(FOO_FILE.toPath(), BAR_FILE.toPath());
+                assertThat(op.options().get(CLASS_PATH)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void classPathAsStringList() {
+                var op = new PitestOperation().classPathPaths(List.of(FOO_FILE.toPath(), BAR_FILE.toPath()));
+                assertThat(op.options().get(CLASS_PATH)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void useClasspathJar() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .useClasspathJar(true);
+                assertThat(op.options().get("--useClasspathJar")).isEqualTo(TRUE);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .useClasspathJar(false);
+                assertThat(op.options().get("--useClasspathJar")).isEqualTo(FALSE);
+            }
+        }
+
+        @Nested
+        @DisplayName("Excluded Tests")
+        class ExcludedTests {
+            @Test
+            void excludedClasses() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .excludedClasses(FOO, BAR);
+                assertThat(op.options().get("--excludedClasses")).isEqualTo(FOOBAR);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .excludedClasses(Set.of(FOO, BAR));
+                assertThat(op.options().get("--excludedClasses")).contains(",");
+            }
+
+            @Test
+            void excludedGroupsAsList() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .excludedGroups(List.of(FOO, BAR));
+                assertThat(op.options().get("--excludedGroups")).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void excludedGroupsAsStringArray() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .excludedGroups(FOO, BAR);
+                assertThat(op.options().get("--excludedGroups")).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void excludedMethods() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .excludedMethods(FOO, BAR);
+                assertThat(op.options().get("--excludedMethods")).isEqualTo(FOOBAR);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .excludedMethods(List.of(FOO, BAR));
+                assertThat(op.options().get("--excludedMethods")).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void excludedRunners() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .excludedRunners(FOO);
+                assertThat(op.options().get("--excludedRunners")).isEqualTo(FOO);
+            }
+
+            @Test
+            void excludedTestsAsList() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .excludedTestClasses(List.of(FOO, BAR));
+                assertThat(op.options().get("--excludedTestClasses")).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void excludedTestsAsStringArray() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .excludedTestClasses(FOO, BAR);
+                assertThat(op.options().get("--excludedTestClasses")).isEqualTo(FOOBAR);
+            }
+        }
+
+        @Nested
+        @DisplayName("History Location Tests")
+        class HistoryLocationTests {
+            private static final String historyInputLocation = "--historyInputLocation";
+            private static final String historyOutputLocation = "--historyOutputLocation";
+            private final PitestOperation op = new PitestOperation().fromProject(new WebProject());
+
+            @Test
+            void historyInputLocationAsFile() {
+                op.historyInputLocation(FOO_FILE);
+                assertThat(op.options().get(historyInputLocation)).isEqualTo(FOO_FILE.getAbsolutePath());
+            }
+
+            @Test
+            void historyInputLocationAsPath() {
+                var op = new PitestOperation().historyInputLocation(FOO_FILE.toPath());
+                assertThat(op.options().get(historyInputLocation)).isEqualTo(FOO_FILE.getAbsolutePath());
+            }
+
+            @Test
+            void historyInputLocationAsString() {
+                op.historyInputLocation(FOO);
+                assertThat(op.options().get(historyInputLocation)).isEqualTo(FOO);
+            }
+
+            @Test
+            void historyOutputLocationAsPath() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .historyOutputLocation(FOO_FILE.toPath());
+                assertThat(op.options().get(historyOutputLocation)).isEqualTo(FOO_FILE.getAbsolutePath());
+            }
+
+            @Test
+            void historyOutputLocationAsString() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .historyOutputLocation(FOO);
+                assertThat(op.options().get(historyOutputLocation)).isEqualTo(FOO);
+            }
+        }
+
+        @Nested
+        @DisplayName("Include Test")
+        class IncludeTest {
+            @Test
+            void includeLaunchClasspath() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .includeLaunchClasspath(true);
+                assertThat(op.options().get("--includeLaunchClasspath")).isEqualTo(TRUE);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .includeLaunchClasspath(false);
+                assertThat(op.options().get("--includeLaunchClasspath")).isEqualTo(FALSE);
+            }
+
+            @Test
+            void includedGroups() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .includedGroups(FOO, BAR);
+                assertThat(op.options().get("--includedGroups")).isEqualTo(FOOBAR);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .includedGroups(List.of(FOO, BAR));
+                assertThat(op.options().get("--includedGroups")).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void includedTestMethods() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .includedTestMethods(FOO);
+                assertThat(op.options().get("--includedTestMethods")).isEqualTo(FOO);
+            }
+        }
+
+        @Nested
+        @DisplayName("JVM Tests")
+        class JvmTests {
+            @Test
+            void jvmArgs() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .jvmArgs(FOO, BAR);
+                assertThat(op.options().get("--jvmArgs")).isEqualTo(FOOBAR);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .jvmArgs(List.of(FOO, BAR));
+                assertThat(op.options().get("--jvmArgs")).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void jvmPath() {
+                var op = new PitestOperation().jvmPath(FOO);
+                assertThat(op.options().get("--jvmPath")).isEqualTo(FOO);
+
+                op = new PitestOperation().jvmPath(FOO_FILE);
+                assertThat(op.options().get("--jvmPath")).isEqualTo(FOO_FILE.getAbsolutePath());
+
+                op = new PitestOperation().jvmPath(FOO_FILE.toPath());
+                assertThat(op.options().get("--jvmPath")).isEqualTo(FOO_FILE.getAbsolutePath());
+            }
+        }
+
+        @Nested
+        @DisplayName("Mutable Code Paths Tests")
+        class MutableCodePathsTests {
+
+            private static final String MUTABLE_CODE_PATHS = "--mutableCodePaths";
+
+            @Test
+            void mutableCodePathsAsFileArray() {
+                var op = new PitestOperation().mutableCodePaths(FOO_FILE, BAR_FILE);
+                assertThat(op.options().get(MUTABLE_CODE_PATHS)).isEqualTo(FOOBAR_FORMAT);
+
+            }
+
+            @Test
+            void mutableCodePathsAsFileList() {
+                var op = new PitestOperation().mutableCodePathsFiles(List.of(FOO_FILE, BAR_FILE));
+                assertThat(op.options().get(MUTABLE_CODE_PATHS)).isEqualTo(FOOBAR_FORMAT);
+
+            }
+
+            @Test
+            void mutableCodePathsAsPathArray() {
+                var op = new PitestOperation().mutableCodePaths(FOO_FILE.toPath(), BAR_FILE.toPath());
+                assertThat(op.options().get(MUTABLE_CODE_PATHS)).isEqualTo(FOOBAR_FORMAT);
+
+            }
+
+            @Test
+            void mutableCodePathsAsPathList() {
+                var op = new PitestOperation().mutableCodePathsPaths(List.of(FOO_FILE.toPath(), BAR_FILE.toPath()));
+                assertThat(op.options().get(MUTABLE_CODE_PATHS)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void mutableCodePathsAsStringArray() {
+                var op = new PitestOperation().mutableCodePaths(FOO, BAR);
+                assertThat(op.options().get(MUTABLE_CODE_PATHS)).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void mutableCodePathsAsStringList() {
+                var op = new PitestOperation().mutableCodePaths(List.of(FOO, BAR));
+                assertThat(op.options().get(MUTABLE_CODE_PATHS)).isEqualTo(FOOBAR);
+
+            }
+        }
+
+        @Nested
+        @DisplayName("Mutation Tests")
+        class MutationTests {
+            @Test
+            void failWhenNoMutations() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .failWhenNoMutations(true);
+                assertThat(op.options().get("--failWhenNoMutations")).isEqualTo(TRUE);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .failWhenNoMutations(false);
+                assertThat(op.options().get("--failWhenNoMutations")).isEqualTo(FALSE);
+            }
+
+            @Test
+            void fullMutationMatrix() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .fullMutationMatrix(true);
+                assertThat(op.options().get("--fullMutationMatrix")).isEqualTo(TRUE);
+            }
+
+            @Test
+            void maxMutationsPerClass() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .maxMutationsPerClass(12);
+                assertThat(op.options().get("--maxMutationsPerClass")).isEqualTo("12");
+            }
+
+            @Test
+            void mutationEngine() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .mutationEngine(FOO);
+                assertThat(op.options().get("--mutationEngine")).isEqualTo(FOO);
+            }
+
+            @Test
+            void mutationThreshold() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .mutationThreshold(3);
+                assertThat(op.options().get("--mutationThreshold")).isEqualTo("3");
+
+                op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .mutationThreshold(101);
+                assertThat(op.options().get("--mutationThreshold")).isNull();
+            }
+
+            @Test
+            void mutationUnitSize() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .mutationUnitSize(2);
+                assertThat(op.options().get("--mutationUnitSize")).isEqualTo("2");
+            }
+
+            @Test
+            void mutators() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .mutators(FOO, BAR);
+                assertThat(op.options().get("--mutators")).isEqualTo(FOOBAR);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .mutators(List.of(FOO, BAR));
+                assertThat(op.options().get("--mutators")).isEqualTo(FOOBAR);
+            }
+        }
+
+        @Nested
+        @DisplayName("Output Tests")
+        class OutputTests {
+            private static final String OUTPUT_FORMATS = "--outputFormats";
+
+            @Test
+            void outputEncoding() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .outputEncoding(FOO);
+                assertThat(op.options().get("--outputEncoding")).isEqualTo(FOO);
+            }
+
+            @Nested
+            @DisplayName("Output Formats Tests")
+            class OutputFormatsTests {
+                @Test
+                void outputFormatsAsFileArray() {
+                    var op = new PitestOperation().outputFormats(FOO_FILE, BAR_FILE);
+                    assertThat(op.options().get(OUTPUT_FORMATS)).isEqualTo(FOOBAR_FORMAT);
+
+                }
+
+                @Test
+                void outputFormatsAsFileList() {
+                    var op = new PitestOperation().outputFormatsFiles(List.of(FOO_FILE, BAR_FILE));
+                    assertThat(op.options().get(OUTPUT_FORMATS)).isEqualTo(FOOBAR_FORMAT);
+
+                }
+
+                @Test
+                void outputFormatsAsPathArray() {
+                    var op = new PitestOperation().outputFormats(FOO_FILE.toPath(), BAR_FILE.toPath());
+                    assertThat(op.options().get(OUTPUT_FORMATS)).isEqualTo(FOOBAR_FORMAT);
+
+                }
+
+                @Test
+                void outputFormatsAsPathList() {
+                    var op = new PitestOperation().outputFormatsPaths(List.of(FOO_FILE.toPath(), BAR_FILE.toPath()));
+                    assertThat(op.options().get(OUTPUT_FORMATS)).isEqualTo(FOOBAR_FORMAT);
+                }
+
+                @Test
+                void outputFormatsAsStringArray() {
+                    var op = new PitestOperation().outputFormats(FOO, BAR);
+                    assertThat(op.options().get(OUTPUT_FORMATS)).isEqualTo(FOO + ',' + BAR);
+                }
+
+                @Test
+                void outputFormatsAsStringList() {
+                    var op = new PitestOperation().outputFormats(List.of(FOO, BAR));
+                    assertThat(op.options().get(OUTPUT_FORMATS)).isEqualTo(FOO + ',' + BAR);
+
+                }
+            }
+        }
+
+        @Nested
+        @DisplayName("Report Tests")
+        class ReportTests {
+            private static final String REPORT_DIR = "--reportDir";
+
+            @Test
+            void reportDirAsFile() {
+                var op = new PitestOperation().reportDir(FOO_FILE);
+                assertThat(op.options().get(REPORT_DIR)).isEqualTo(FOO_FILE.getAbsolutePath());
+            }
+
+            @Test
+            void reportDirAsPath() {
+                var op = new PitestOperation().reportDir(FOO_FILE.toPath());
+                assertThat(op.options().get(REPORT_DIR)).isEqualTo(FOO_FILE.getAbsolutePath());
+            }
+
+            @Test
+            void reportDirAsString() {
+                var op = new PitestOperation().reportDir(FOO);
+                assertThat(op.options().get(REPORT_DIR)).isEqualTo(FOO);
+            }
+        }
+
+        @Nested
+        @DisplayName("Source Directories Tests")
+        class SourceDirectoriesTests {
+            private static final String SOURCE_DIRS = "--sourceDirs";
+
+            @Test
+            void sourceDirsAsFileArray() {
+                var op = new PitestOperation().sourceDirs(FOO_FILE, BAR_FILE);
+                assertThat(op.options().get(SOURCE_DIRS)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void sourceDirsAsFileList() {
+                var op = new PitestOperation().sourceDirsFiles(List.of(FOO_FILE, BAR_FILE));
+                assertThat(op.options().get(SOURCE_DIRS)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void sourceDirsAsPathArray() {
+                var op = new PitestOperation().sourceDirs(FOO_FILE.toPath(), BAR_FILE.toPath());
+                assertThat(op.options().get(SOURCE_DIRS)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void sourceDirsAsPathList() {
+                var op = new PitestOperation().sourceDirsPaths(List.of(FOO_FILE.toPath(), BAR_FILE.toPath()));
+                assertThat(op.options().get(SOURCE_DIRS)).isEqualTo(FOOBAR_FORMAT);
+            }
+
+            @Test
+            void sourceDirsAsStringArray() {
+                var op = new PitestOperation().sourceDirs(FOO, BAR);
+                assertThat(op.options().get(SOURCE_DIRS)).isEqualTo(FOO + ',' + BAR);
+            }
+
+            @Test
+            void sourceDirsAsStringList() {
+                var op = new PitestOperation().sourceDirs(List.of(FOO, BAR));
+                assertThat(op.options().get(SOURCE_DIRS)).isEqualTo(FOO + ',' + BAR);
+            }
+        }
+
+        @Nested
+        @DisplayName("Target Tests")
+        class TargetTests {
+            @Test
+            void targetClasses() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .targetClasses(FOO, BAR);
+                assertThat(op.options().get("--targetClasses")).isEqualTo(FOOBAR);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .targetClasses(List.of(FOO, BAR));
+                assertThat(op.options().get("--targetClasses")).isEqualTo(FOOBAR);
+            }
+
+            @Test
+            void targetTests() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .targetTests(FOO, BAR);
+                assertThat(op.options().get("--targetTests")).isEqualTo(FOOBAR);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .targetTests(List.of(FOO, BAR));
+                assertThat(op.options().get("--targetTests")).isEqualTo(FOOBAR);
+            }
+        }
+
+        @Nested
+        @DisplayName("Timeout Tests")
+        class TimeoutTests {
+            @Test
+            void timeoutConst() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .timeoutConst(300);
+                assertThat(op.options().get("--timeoutConst")).isEqualTo("300");
+            }
+
+            @Test
+            void timeoutFactor() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .timeoutFactor(5.25);
+                assertThat(op.options().get("--timeoutFactor")).isEqualTo("5.25");
+            }
+        }
+
+        @Nested
+        @DisplayName("Verbose Tests")
+        class VerboseTests {
+            @Test
+            void verbose() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .verbose(true);
+                assertThat(op.options().get("--verbose")).isEqualTo(TRUE);
+
+                op = new PitestOperation()
+                        .fromProject(new Project())
+                        .verbose(false);
+                assertThat(op.options().get("--verbose")).isEqualTo(FALSE);
+            }
+
+            @Test
+            void verbosity() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .verbosity(FOO);
+                assertThat(op.options().get("--verbosity")).isEqualTo(FOO);
+            }
+        }
     }
 }