Cleanup more tests

.github/workflows/bld.yml

@@ -7,7 +7,6 @@ jobs:
     strategy:
       matrix:
         java-version: [17, 21, 24]
-        kotlin-version: [ 1.9.25, 2.0.21, 2.1.20 ]
         os: [ubuntu-latest, windows-latest, macos-latest]
 
     runs-on: ${{ matrix.os }}

.idea/inspectionProfiles/Project_Default.xml

@@ -4,5 +4,6 @@
     <inspection_tool class="JavadocDeclaration" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ADDITIONAL_TAGS" value="created" />
     </inspection_tool>
+    <inspection_tool class="UsePropertyAccessSyntax" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
   </profile>
 </component>

README.md

@@ -48,7 +48,7 @@ Don't forget to add the Pitest `test` dependencies to your build file, as they a
 ```java
 repositories = List.of(MAVEN_CENTRAL);
 scope(test)
-    .include(dependency("org.pitest", "pitest", version(1, 19, 2)))
+    .include(dependency("org.pitest", "pitest", version(1, 19, 3)))
     .include(dependency("org.pitest", "pitest-command-line", version(1, 19, 2)))
     .include(dependency("org.pitest", "pitest-junit5-plugin", version(1, 2, 2)))
     .include(dependency("org.pitest", "pitest-testng-plugin", version(1, 0, 0)));

examples/src/bld/java/com/example/ExamplesBuild.java

@@ -29,7 +29,7 @@ public class ExamplesBuild extends Project {
 
         repositories = List.of(MAVEN_CENTRAL, RIFE2_RELEASES);
 
-        var pitest = version(1, 19, 2);
+        var pitest = version(1, 19, 3);
         scope(test)
                 .include(dependency("org.pitest", "pitest", pitest))
                 .include(dependency("org.pitest", "pitest-command-line", pitest))

src/bld/java/rife/bld/extension/PitestOperationBuild.java

@@ -22,6 +22,9 @@ import rife.bld.publish.PublishDeveloper;
 import rife.bld.publish.PublishLicense;
 import rife.bld.publish.PublishScm;
 
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.List;
 
 import static rife.bld.dependencies.Repository.*;
@@ -47,7 +50,7 @@ public class PitestOperationBuild extends Project {
 
         repositories = List.of(MAVEN_LOCAL, MAVEN_CENTRAL, RIFE2_RELEASES, RIFE2_SNAPSHOTS);
 
-        var pitest = version(1, 19, 2);
+        var pitest = version(1, 19, 3);
         scope(compile)
                 .include(dependency("com.uwyn.rife2", "bld", version(2, 2, 1)));
         scope(test)
@@ -115,6 +118,22 @@ public class PitestOperationBuild extends Project {
                     .command("scripts/cliargs.sh")
                     .execute();
         }
-        super.test();
+
+        var testResultsDir = "build/test-results/test/";
+        var op = testOperation().fromProject(this);
+        op.testToolOptions().reportsDir(new File(testResultsDir));
+        op.execute();
+
+        var xunitViewer = new File("/usr/bin/xunit-viewer");
+        if (xunitViewer.exists() && xunitViewer.canExecute()) {
+            var reportsDir = "build/reports/tests/test/";
+
+            Files.createDirectories(Path.of(reportsDir));
+
+            new ExecOperation()
+                    .fromProject(this)
+                    .command(xunitViewer.getPath(), "-r", testResultsDir, "-o", reportsDir + "index.html")
+                    .execute();
+        }
     }
 }

src/test/java/rife/bld/extension/PitestOperationTest.java

@@ -51,7 +51,6 @@ class PitestOperationTest {
     @Nested
     @DisplayName("Execute Tests")
     class ExecuteTests {
-
         @Test
         void execute() throws IOException {
             var tmpDir = Files.createTempDirectory("bld-pitest-");
@@ -110,16 +109,19 @@ class PitestOperationTest {
         }
 
         @Test
-        void exportLineCoverage() {
+        void exportLineCoverageIsFalse() {
+            var op = new PitestOperation()
+                    .fromProject(new Project())
+                    .exportLineCoverage(false);
+            assertThat(op.options().get("--exportLineCoverage")).isEqualTo(FALSE);
+        }
+
+        @Test
+        void exportLineCoverageIsTrue() {
             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);
         }
     }
 
@@ -140,8 +142,11 @@ class PitestOperationTest {
                     .fromProject(new BaseProject())
                     .avoidCallsTo(FOO, BAR);
             assertThat(op.options().get("--avoidCallsTo")).isEqualTo(FOOBAR);
+        }
 
-            op = new PitestOperation()
+        @Test
+        void avoidCallsToAsList() {
+            var op = new PitestOperation()
                     .fromProject(new Project())
                     .avoidCallsTo(List.of(FOO, BAR));
             assertThat(op.options().get("--avoidCallsTo")).isEqualTo(FOOBAR);
@@ -228,24 +233,38 @@ class PitestOperationTest {
                     .fromProject(new BaseProject())
                     .coverageThreshold(3);
             assertThat(op.options().get("--coverageThreshold")).isEqualTo("3");
+        }
 
-            op = new PitestOperation()
+        @Test
+        void coverageThresholdOutOfBounds() {
+            var op = new PitestOperation()
                     .fromProject(new BaseProject())
                     .coverageThreshold(101);
             assertThat(op.options().get("--coverageThreshold")).isNull();
         }
 
         @Test
-        void detectInlinedCode() {
+        void coverageThresholdOutOfBoundsNegative() {
+            var op = new PitestOperation()
+                    .fromProject(new BaseProject())
+                    .coverageThreshold(-1);
+            assertThat(op.options().get("--coverageThreshold")).isNull();
+        }
+
+        @Test
+        void detectInlinedCodeIsFalse() {
+            var op = new PitestOperation()
+                    .fromProject(new Project())
+                    .detectInlinedCode(false);
+            assertThat(op.options().get("--detectInlinedCode")).isEqualTo(FALSE);
+        }
+
+        @Test
+        void detectInlinedCodeIsTrue() {
             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
@@ -254,8 +273,11 @@ class PitestOperationTest {
                     .fromProject(new BaseProject())
                     .features(FOO, BAR);
             assertThat(op.options().get("--features")).isEqualTo(FOOBAR);
+        }
 
-            op = new PitestOperation()
+        @Test
+        void featuresAsList() {
+            var op = new PitestOperation()
                     .fromProject(new Project())
                     .features(List.of(FOO, BAR));
             assertThat(op.options().get("--features")).isEqualTo(FOOBAR);
@@ -289,28 +311,35 @@ class PitestOperationTest {
         @Test
         void projectBase() {
             var op = new PitestOperation().projectBase(FOO);
-            var key = "--projectBase";
+            assertThat(op.options().get("--projectBase")).isEqualTo(FOO);
-
-            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() {
+        void projectBaseAsFile() {
+            var op = new PitestOperation().projectBase(FOO_FILE);
+            assertThat(op.options().get("--projectBase")).isEqualTo(FOO_FILE.getAbsolutePath());
+        }
+
+        @Test
+        void projectBaseAsPath() {
+            var op = new PitestOperation().projectBase(FOO_FILE.toPath());
+            assertThat(op.options().get("--projectBase")).isEqualTo(FOO_FILE.getAbsolutePath());
+        }
+
+        @Test
+        void skipFailingTestsIsFalse() {
+            var op = new PitestOperation()
+                    .fromProject(new Project())
+                    .skipFailingTests(false);
+            assertThat(op.options().get("--skipFailingTests")).isEqualTo(FALSE);
+        }
+
+        @Test
+        void skipFailingTestsIsTrue() {
             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
@@ -330,16 +359,19 @@ class PitestOperationTest {
         }
 
         @Test
-        void timestampedReports() {
+        void timestampedReportsIsFalse() {
+            var op = new PitestOperation()
+                    .fromProject(new Project())
+                    .timestampedReports(false);
+            assertThat(op.options().get("--timestampedReports")).isEqualTo(FALSE);
+        }
+
+        @Test
+        void timestampedReportsIsTrue() {
             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
@@ -347,6 +379,12 @@ class PitestOperationTest {
         class ClassPathTests {
             private static final String CLASS_PATH = "--classPath";
 
+            @Test
+            void classPath() {
+                var op = new PitestOperation().classPath(FOO_FILE.toPath(), BAR_FILE.toPath());
+                assertThat(op.options().get(CLASS_PATH)).isEqualTo(FOOBAR_FORMAT);
+            }
+
             @Test
             void classPathAsFile() {
                 var op = new PitestOperation()
@@ -375,12 +413,6 @@ class PitestOperationTest {
                 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()));
@@ -388,16 +420,19 @@ class PitestOperationTest {
             }
 
             @Test
-            void useClasspathJar() {
+            void useClasspathJarIsFalse() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .useClasspathJar(false);
+                assertThat(op.options().get("--useClasspathJar")).isEqualTo(FALSE);
+            }
+
+            @Test
+            void useClasspathJarIsTrue() {
                 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);
             }
         }
 
@@ -410,13 +445,24 @@ class PitestOperationTest {
                         .fromProject(new BaseProject())
                         .excludedClasses(FOO, BAR);
                 assertThat(op.options().get("--excludedClasses")).isEqualTo(FOOBAR);
+            }
 
-                op = new PitestOperation()
+            @Test
+            void excludedClassesAsList() {
+                var op = new PitestOperation()
                         .fromProject(new Project())
                         .excludedClasses(Set.of(FOO, BAR));
                 assertThat(op.options().get("--excludedClasses")).contains(",");
             }
 
+            @Test
+            void excludedGroups() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .excludedGroups(FOO, BAR);
+                assertThat(op.options().get("--excludedGroups")).isEqualTo(FOOBAR);
+            }
+
             @Test
             void excludedGroupsAsList() {
                 var op = new PitestOperation()
@@ -425,14 +471,6 @@ class PitestOperationTest {
                 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()
@@ -455,18 +493,18 @@ class PitestOperationTest {
             }
 
             @Test
-            void excludedTestsAsList() {
+            void excludedTests() {
                 var op = new PitestOperation()
-                        .fromProject(new Project())
+                        .fromProject(new BaseProject())
-                        .excludedTestClasses(List.of(FOO, BAR));
+                        .excludedTestClasses(FOO, BAR);
                 assertThat(op.options().get("--excludedTestClasses")).isEqualTo(FOOBAR);
             }
 
             @Test
-            void excludedTestsAsStringArray() {
+            void excludedTestsAsList() {
                 var op = new PitestOperation()
-                        .fromProject(new BaseProject())
+                        .fromProject(new Project())
-                        .excludedTestClasses(FOO, BAR);
+                        .excludedTestClasses(List.of(FOO, BAR));
                 assertThat(op.options().get("--excludedTestClasses")).isEqualTo(FOOBAR);
             }
         }
@@ -517,16 +555,19 @@ class PitestOperationTest {
         @DisplayName("Include Test")
         class IncludeTest {
             @Test
-            void includeLaunchClasspath() {
+            void includeLaunchClasspathIsFalse() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .includeLaunchClasspath(false);
+                assertThat(op.options().get("--includeLaunchClasspath")).isEqualTo(FALSE);
+            }
+
+            @Test
+            void includeLaunchClasspathIsTrue() {
                 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
@@ -535,8 +576,11 @@ class PitestOperationTest {
                         .fromProject(new BaseProject())
                         .includedGroups(FOO, BAR);
                 assertThat(op.options().get("--includedGroups")).isEqualTo(FOOBAR);
+            }
 
-                op = new PitestOperation()
+            @Test
+            void includedGroupsAsList() {
+                var op = new PitestOperation()
                         .fromProject(new Project())
                         .includedGroups(List.of(FOO, BAR));
                 assertThat(op.options().get("--includedGroups")).isEqualTo(FOOBAR);
@@ -560,8 +604,11 @@ class PitestOperationTest {
                         .fromProject(new BaseProject())
                         .jvmArgs(FOO, BAR);
                 assertThat(op.options().get("--jvmArgs")).isEqualTo(FOOBAR);
+            }
 
-                op = new PitestOperation()
+            @Test
+            void jvmArgsAsList() {
+                var op = new PitestOperation()
                         .fromProject(new Project())
                         .jvmArgs(List.of(FOO, BAR));
                 assertThat(op.options().get("--jvmArgs")).isEqualTo(FOOBAR);
@@ -571,11 +618,17 @@ class PitestOperationTest {
             void jvmPath() {
                 var op = new PitestOperation().jvmPath(FOO);
                 assertThat(op.options().get("--jvmPath")).isEqualTo(FOO);
+            }
 
-                op = new PitestOperation().jvmPath(FOO_FILE);
+            @Test
+            void jvmPathAsFile() {
+                var op = new PitestOperation().jvmPath(FOO_FILE);
                 assertThat(op.options().get("--jvmPath")).isEqualTo(FOO_FILE.getAbsolutePath());
+            }
 
-                op = new PitestOperation().jvmPath(FOO_FILE.toPath());
+            @Test
+            void jvmPathAsPath() {
+                var op = new PitestOperation().jvmPath(FOO_FILE.toPath());
                 assertThat(op.options().get("--jvmPath")).isEqualTo(FOO_FILE.getAbsolutePath());
             }
         }
@@ -583,28 +636,30 @@ class PitestOperationTest {
         @Nested
         @DisplayName("Mutable Code Paths Tests")
         class MutableCodePathsTests {
-
             private static final String MUTABLE_CODE_PATHS = "--mutableCodePaths";
 
+            @Test
+            void mutableCodePaths() {
+                var op = new PitestOperation().mutableCodePaths(FOO, BAR);
+                assertThat(op.options().get(MUTABLE_CODE_PATHS)).isEqualTo(FOOBAR);
+            }
+
             @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
@@ -613,17 +668,10 @@ class PitestOperationTest {
                 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);
-
             }
         }
 
@@ -631,20 +679,31 @@ class PitestOperationTest {
         @DisplayName("Mutation Tests")
         class MutationTests {
             @Test
-            void failWhenNoMutations() {
+            void failWhenNoMutationsIsFalse() {
                 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() {
+            void failWhenNoMutationsIsTrue() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .failWhenNoMutations(true);
+                assertThat(op.options().get("--failWhenNoMutations")).isEqualTo(TRUE);
+            }
+
+            @Test
+            void fullMutationMatrixIsFalse() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .fullMutationMatrix(false);
+                assertThat(op.options().get("--fullMutationMatrix")).isEqualTo(FALSE);
+            }
+
+            @Test
+            void fullMutationMatrixIsTrue() {
                 var op = new PitestOperation()
                         .fromProject(new BaseProject())
                         .fullMutationMatrix(true);
@@ -673,13 +732,24 @@ class PitestOperationTest {
                         .fromProject(new BaseProject())
                         .mutationThreshold(3);
                 assertThat(op.options().get("--mutationThreshold")).isEqualTo("3");
+            }
 
-                op = new PitestOperation()
+            @Test
+            void mutationThresholdOutOfBounds() {
+                var op = new PitestOperation()
                         .fromProject(new BaseProject())
                         .mutationThreshold(101);
                 assertThat(op.options().get("--mutationThreshold")).isNull();
             }
 
+            @Test
+            void mutationThresholdOutOfBoundsNegative() {
+                var op = new PitestOperation()
+                        .fromProject(new BaseProject())
+                        .mutationThreshold(-1);
+                assertThat(op.options().get("--mutationThreshold")).isNull();
+            }
+
             @Test
             void mutationUnitSize() {
                 var op = new PitestOperation()
@@ -694,8 +764,11 @@ class PitestOperationTest {
                         .fromProject(new BaseProject())
                         .mutators(FOO, BAR);
                 assertThat(op.options().get("--mutators")).isEqualTo(FOOBAR);
+            }
 
-                op = new PitestOperation()
+            @Test
+            void mutatorsAsList() {
+                var op = new PitestOperation()
                         .fromProject(new Project())
                         .mutators(List.of(FOO, BAR));
                 assertThat(op.options().get("--mutators")).isEqualTo(FOOBAR);
@@ -718,25 +791,28 @@ class PitestOperationTest {
             @Nested
             @DisplayName("Output Formats Tests")
             class OutputFormatsTests {
+                @Test
+                void outputFormats() {
+                    var op = new PitestOperation().outputFormats(FOO, BAR);
+                    assertThat(op.options().get(OUTPUT_FORMATS)).isEqualTo(FOO + ',' + BAR);
+                }
+
                 @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
@@ -745,17 +821,10 @@ class PitestOperationTest {
                     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);
-
                 }
             }
         }
@@ -789,6 +858,12 @@ class PitestOperationTest {
         class SourceDirectoriesTests {
             private static final String SOURCE_DIRS = "--sourceDirs";
 
+            @Test
+            void sourceDirs() {
+                var op = new PitestOperation().sourceDirs(FOO, BAR);
+                assertThat(op.options().get(SOURCE_DIRS)).isEqualTo(FOO + ',' + BAR);
+            }
+
             @Test
             void sourceDirsAsFileArray() {
                 var op = new PitestOperation().sourceDirs(FOO_FILE, BAR_FILE);
@@ -813,12 +888,6 @@ class PitestOperationTest {
                 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));
@@ -835,8 +904,11 @@ class PitestOperationTest {
                         .fromProject(new BaseProject())
                         .targetClasses(FOO, BAR);
                 assertThat(op.options().get("--targetClasses")).isEqualTo(FOOBAR);
+            }
 
-                op = new PitestOperation()
+            @Test
+            void targetClassesAsList() {
+                var op = new PitestOperation()
                         .fromProject(new Project())
                         .targetClasses(List.of(FOO, BAR));
                 assertThat(op.options().get("--targetClasses")).isEqualTo(FOOBAR);
@@ -848,8 +920,11 @@ class PitestOperationTest {
                         .fromProject(new BaseProject())
                         .targetTests(FOO, BAR);
                 assertThat(op.options().get("--targetTests")).isEqualTo(FOOBAR);
+            }
 
-                op = new PitestOperation()
+            @Test
+            void targetTestsAsList() {
+                var op = new PitestOperation()
                         .fromProject(new Project())
                         .targetTests(List.of(FOO, BAR));
                 assertThat(op.options().get("--targetTests")).isEqualTo(FOOBAR);
@@ -880,16 +955,19 @@ class PitestOperationTest {
         @DisplayName("Verbose Tests")
         class VerboseTests {
             @Test
-            void verbose() {
+            void verboseIsFalse() {
+                var op = new PitestOperation()
+                        .fromProject(new Project())
+                        .verbose(false);
+                assertThat(op.options().get("--verbose")).isEqualTo(FALSE);
+            }
+
+            @Test
+            void verboseIsTrue() {
                 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