Clean up project

Author: Donnerbart

src/main/java/de/donnerbart/split/TestLoader.java

@@ -107,7 +107,7 @@ public TestLoader(
         return testCases;
     }
 
-    private @NotNull Set<Path> getPaths(
+    private static @NotNull Set<Path> getPaths(
             final @NotNull Path rootPath,
             final @NotNull String glob,
             final @Nullable String excludeGlob) throws Exception {
@@ -140,7 +140,7 @@ public TestLoader(
         return files;
     }
 
-    private @NotNull Set<String> fileToClassName(
+    private static @NotNull Set<String> fileToClassName(
             final @NotNull Set<Path> testPaths,
             final @NotNull Consumer<Integer> exitCodeConsumer) {
         final var javaParser = new JavaParser();
@@ -161,13 +161,15 @@ public TestLoader(
                         .stream()
                         .map(NodeWithName::getNameAsString)
                         .anyMatch(SKIP_TEST_IMPORTS::contains);
-                final var hasSkipTestAnnotation = declaration.getAnnotations()
-                        .stream()
-                        .map(AnnotationExpr::getNameAsString)
-                        .anyMatch(SKIP_TEST_ANNOTATIONS::contains);
-                if (hasSkipTestImport && hasSkipTestAnnotation) {
-                    LOG.info("Skipping disabled test class {}", className);
-                    continue;
+                if (hasSkipTestImport) {
+                    final var hasSkipTestAnnotation = declaration.getAnnotations()
+                            .stream()
+                            .map(AnnotationExpr::getNameAsString)
+                            .anyMatch(SKIP_TEST_ANNOTATIONS::contains);
+                    if (hasSkipTestAnnotation) {
+                        LOG.info("Skipping disabled test class {}", className);
+                        continue;
+                    }
                 }
                 classNames.add(className);
             } catch (final Exception e) {
@@ -178,7 +180,7 @@ public TestLoader(
         return classNames;
     }
 
-    private double getNewTestTime(
+    private static double getNewTestTime(
             final @NotNull NewTestTimeOption useAverageTimeForNewTests,
             final @NotNull Set<TestCase> testCases) {
         if (testCases.isEmpty()) {

src/main/java/de/donnerbart/split/TestSplit.java

@@ -5,7 +5,6 @@
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.slf4j.helpers.NOPLogger;
 
 import java.util.Comparator;
 import java.util.Set;
@@ -14,51 +13,54 @@
 
 public class TestSplit {
 
+    private static final @NotNull Logger LOG = LoggerFactory.getLogger(TestSplit.class);
+
     private final @NotNull Set<TestCase> testCases;
     private final int splitTotal;
     private final @NotNull FormatOption formatOption;
-    private final @NotNull Logger log;
     private final boolean debug;
 
     public TestSplit(
             final @NotNull Set<TestCase> testCases,
             final int splitTotal,
             final @NotNull FormatOption formatOption,
-            final boolean log,
             final boolean debug) {
         this.testCases = testCases;
         this.splitTotal = splitTotal;
         this.formatOption = formatOption;
-        this.log = log ? LoggerFactory.getLogger(TestSplit.class) : NOPLogger.NOP_LOGGER;
         this.debug = debug;
     }
 
     public @NotNull Splits split() {
         // split tests
-        log.debug("Splitting {} tests", testCases.size());
+        if (debug) {
+            LOG.debug("Splitting {} tests", testCases.size());
+        }
         final var splits = new Splits(splitTotal, formatOption);
         testCases.stream().sorted(Comparator.reverseOrder()).forEach(testCase -> {
             final var split = splits.add(testCase);
-            log.debug("Adding test {} to split #{}", testCase.name(), split.index());
+            if (debug) {
+                LOG.debug("Adding test {} to split #{}", testCase.name(), split.index());
+            }
         });
 
         if (debug) {
             if (splitTotal > 1) {
                 final var fastestSplit = splits.getFastest();
-                log.debug("Fastest test plan is #{} with {} tests ({})",
+                LOG.debug("Fastest test plan is #{} with {} tests ({})",
                         fastestSplit.formatIndex(),
                         fastestSplit.tests().size(),
                         formatTime(fastestSplit.totalRecordedTime()));
                 final var slowestSplit = splits.getSlowest();
-                log.debug("Slowest test plan is #{} with {} tests ({})",
+                LOG.debug("Slowest test plan is #{} with {} tests ({})",
                         slowestSplit.formatIndex(),
                         slowestSplit.tests().size(),
                         formatTime(slowestSplit.totalRecordedTime()));
-                log.debug("Difference between the fastest and slowest test plan: {}",
+                LOG.debug("Difference between the fastest and slowest test plan: {}",
                         formatTime(slowestSplit.totalRecordedTime() - fastestSplit.totalRecordedTime()));
             }
-            log.debug("Test splits:");
-            splits.forEach(split -> log.debug(split.toString()));
+            LOG.debug("Test splits:");
+            splits.forEach(split -> LOG.debug(split.toString()));
         }
         return splits;
     }

src/main/java/de/donnerbart/split/TestSplitMain.java

@@ -78,8 +78,7 @@ public static void main(final @Nullable String @NotNull [] args) throws Exceptio
         if (arguments.calculateOptimalTotalSplit) {
             calculateOptimalTotalSplit(arguments, testCases);
         }
-        final var testSplit =
-                new TestSplit(testCases, arguments.splitTotal, arguments.formatOption, true, arguments.debug);
+        final var testSplit = new TestSplit(testCases, arguments.splitTotal, arguments.formatOption, arguments.debug);
         final var splits = testSplit.split();
         final var split = splits.get(arguments.splitIndex);
         LOG.info("This test split has {} tests ({})", split.tests().size(), formatTime(split.totalRecordedTime()));
@@ -118,7 +117,7 @@ static int calculateOptimalTotalSplit(final @NotNull Arguments arguments, final
         var optimalSplit = 1;
         var lastSlowestSplit = Double.MAX_VALUE;
         while (true) {
-            final var testSplit = new TestSplit(testCases, optimalSplit, arguments.formatOption, false, false);
+            final var testSplit = new TestSplit(testCases, optimalSplit, arguments.formatOption, false);
             final var splits = testSplit.split();
             final var slowestSplit = splits.getSlowest().totalRecordedTime();
             if (Double.compare(slowestSplit, lastSlowestSplit) == 0) {

src/test/java/de/donnerbart/split/TestSplitTest.java

@@ -317,7 +317,7 @@ void split_whitespaceClassDefinition() throws Exception {
                 NewTestTimeOption.ZERO,
                 tmp,
                 exitCode::set);
-        final var split = new TestSplit(testLoader.load(), 1, FormatOption.LIST, true, true);
+        final var split = new TestSplit(testLoader.load(), 1, FormatOption.LIST, false);
 
         final var splits = split.split();
         assertThat(splits.size()).isOne();
@@ -416,7 +416,7 @@ void split_noClassName() throws Exception {
                 newTestTimeOption,
                 workingDir,
                 exitCode::set);
-        final var testSplit = new TestSplit(testLoader.load(), splitTotal, formatOption, true, true);
+        final var testSplit = new TestSplit(testLoader.load(), splitTotal, formatOption, true);
         final var splits = testSplit.split();
         final var result = new ArrayList<List<String>>(splitTotal);
         for (int index = 0; index < splitTotal; index++) {