adds filter for enum constructors for #556

pitest-entry/src/main/java/org/pitest/mutationtest/build/intercept/javafeatures/EnumConstructorFilter.java

@@ -0,0 +1,69 @@
+package org.pitest.mutationtest.build.intercept.javafeatures;
+
+import static org.pitest.bytecode.analysis.InstructionMatchers.anyInstruction;
+import static org.pitest.bytecode.analysis.InstructionMatchers.isInstruction;
+import static org.pitest.bytecode.analysis.InstructionMatchers.methodCallTo;
+import static org.pitest.bytecode.analysis.InstructionMatchers.notAnInstruction;
+import static org.pitest.bytecode.analysis.InstructionMatchers.opCode;
+
+import java.util.Collection;
+import java.util.Objects;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.pitest.bytecode.analysis.ClassTree;
+import org.pitest.bytecode.analysis.MethodMatchers;
+import org.pitest.bytecode.analysis.MethodTree;
+import org.pitest.classinfo.ClassName;
+import org.pitest.functional.FCollection;
+import org.pitest.functional.prelude.Prelude;
+import org.pitest.mutationtest.build.InterceptorType;
+import org.pitest.mutationtest.build.MutationInterceptor;
+import org.pitest.mutationtest.engine.Mutater;
+import org.pitest.mutationtest.engine.MutationDetails;
+import org.pitest.sequence.Context;
+import org.pitest.sequence.QueryParams;
+import org.pitest.sequence.QueryStart;
+import org.pitest.sequence.SequenceMatcher;
+import org.pitest.sequence.Slot;
+
+/**
+ * Filters out mutations in Enum constructors, these are called only once
+ * per instance so are effectively static initializers.
+ */
+public class EnumConstructorFilter implements MutationInterceptor {
+
+    private boolean isEnum;
+
+    @Override
+    public InterceptorType type() {
+        return InterceptorType.FILTER;
+    }
+
+    @Override
+    public void begin(ClassTree clazz) {
+        this.isEnum = clazz.rawNode().superName.equals("java/lang/Enum");
+    }
+
+    @Override
+    public Collection<MutationDetails> intercept(
+            Collection<MutationDetails> mutations, Mutater m) {
+        return mutations.stream()
+                .filter(isInEnumConstructor().negate())
+                .collect(Collectors.toList());
+    }
+
+    private Predicate<MutationDetails> isInEnumConstructor() {
+        return m -> isEnum && m.getMethod().name().equals("<init>");
+    }
+
+
+    @Override
+    public void end() {
+;
+    }
+
+}
+

pitest-entry/src/main/java/org/pitest/mutationtest/build/intercept/javafeatures/EnumConstructorFilterFactory.java

@@ -0,0 +1,28 @@
+package org.pitest.mutationtest.build.intercept.javafeatures;
+
+import org.pitest.mutationtest.build.InterceptorParameters;
+import org.pitest.mutationtest.build.MutationInterceptor;
+import org.pitest.mutationtest.build.MutationInterceptorFactory;
+import org.pitest.plugin.Feature;
+
+public class EnumConstructorFilterFactory implements MutationInterceptorFactory {
+
+    @Override
+    public String description() {
+        return "Enum constructor filter";
+    }
+
+    @Override
+    public MutationInterceptor createInterceptor(InterceptorParameters params) {
+        return new EnumConstructorFilter();
+    }
+
+    @Override
+    public Feature provides() {
+        return Feature.named("FENUM")
+                .withOnByDefault(true)
+                .withDescription("Filters mutations in enum constructors");
+    }
+
+}
+

pitest-entry/src/main/resources/META-INF/services/org.pitest.mutationtest.build.MutationInterceptorFactory

@@ -8,6 +8,7 @@ org.pitest.mutationtest.build.intercept.javafeatures.InlinedFinallyBlockFilterFa
 org.pitest.mutationtest.build.intercept.javafeatures.ImplicitNullCheckFilterFactory
 org.pitest.mutationtest.build.intercept.javafeatures.MethodReferenceNullCheckFilterFactory
 org.pitest.mutationtest.build.intercept.javafeatures.ForEachLoopFilterFactory
+org.pitest.mutationtest.build.intercept.javafeatures.EnumConstructorFilterFactory
 org.pitest.mutationtest.build.intercept.logging.LoggingCallsFilterFactory
 org.pitest.mutationtest.build.intercept.timeout.InfiniteForLoopFilterFactory
 org.pitest.mutationtest.build.intercept.timeout.InfiniteIteratorLoopFilterFactory

pitest-entry/src/test/java/org/pitest/mutationtest/build/MutationDiscoveryTest.java

@@ -14,6 +14,7 @@
 import org.pitest.classpath.ClassloaderByteArraySource;
 import org.pitest.mutationtest.EngineArguments;
 import org.pitest.mutationtest.MutationConfig;
+import org.pitest.mutationtest.build.intercept.javafeatures.AnEnum;
 import org.pitest.mutationtest.build.intercept.javafeatures.ForEachFilterTest.HasForEachLoop;
 import org.pitest.mutationtest.config.PluginServices;
 import org.pitest.mutationtest.config.ReportOptions;
@@ -193,6 +194,15 @@ public void shouldFilterMutationsToForEachLoops() {
     assertThat(actual.size()).isLessThan(actualWithoutFilter.size());
   }
 
+  @Test
+  public void shouldFilterMutationsToEnumConstructors() {
+    final Collection<MutationDetails>  actual = findMutants(AnEnum.class);
+
+    this.data.setFeatures(Collections.singletonList("-FENUM"));
+    final Collection<MutationDetails> actualWithoutFilter = findMutants(AnEnum.class);
+
+    assertThat(actual.size()).isLessThan(actualWithoutFilter.size());
+  }
 
   @Test
   public void filtersEquivalentReturnValsMutants() {

pitest-entry/src/test/java/org/pitest/mutationtest/build/intercept/javafeatures/AnEnum.java

@@ -0,0 +1,13 @@
+package org.pitest.mutationtest.build.intercept.javafeatures;
+
+public enum AnEnum {
+    AN_INSTANCE("hello");
+
+    AnEnum(String s) {
+        System.out.println(s);
+    }
+
+    public void aMethod() {
+        System.out.println("dont mutate me");
+    }
+}

pitest-entry/src/test/java/org/pitest/mutationtest/build/intercept/javafeatures/EnumConstructorTest.java

@@ -0,0 +1,39 @@
+package org.pitest.mutationtest.build.intercept.javafeatures;
+
+import org.junit.Test;
+import org.pitest.mutationtest.engine.MutationDetails;
+import java.util.function.Predicate;
+
+import static org.pitest.mutationtest.engine.gregor.mutators.VoidMethodCallMutator.VOID_METHOD_CALL_MUTATOR;
+
+public class EnumConstructorTest {
+
+    EnumConstructorFilter testee = new EnumConstructorFilter();
+
+    FilterTester verifier = new FilterTester("unused", this.testee, VOID_METHOD_CALL_MUTATOR);
+
+    @Test
+    public void filtersMutantsFromEnumConstructor() {
+        this.verifier.assertFiltersMutationsMatching(inMethodNamed("<init>"), AnEnum.class);
+    }
+
+    @Test
+    public void doesNotFilterMutantsInCustomEnumMethods() {
+        this.verifier.assertFiltersNoMutationsMatching(inMethodNamed("aMethod"), AnEnum.class);
+    }
+
+    @Test
+    public void doesNotFilterMutantsInNonEnumConstructors() {
+        this.verifier.assertFiltersNoMutationsMatching(inMethodNamed("<init>"), AClass.class);
+    }
+
+    private Predicate<MutationDetails> inMethodNamed(String name) {
+        return m -> m.getMethod().name().equals(name);
+    }
+}
+
+class AClass {
+    AClass(String s) {
+        System.out.println(s);
+    }
+}

pitest-entry/src/test/java/org/pitest/mutationtest/build/intercept/javafeatures/FilterTester.java

@@ -122,6 +122,63 @@ public void assertFiltersNMutationFromClass(int n, Class<?> clazz) {
     softly.assertAll();
   }
 
+  public void assertFiltersNoMutationsMatching(Predicate<MutationDetails> match, Class<?> clazz) {
+    final Sample s = makeSampleForCurrentCompiler(clazz);
+
+    final SoftAssertions softly = new SoftAssertions();
+    GregorMutater mutator = mutateFromClassLoader();
+
+    assertFiltersNoMatchingMutants(match, mutator, s, softly);
+
+    softly.assertAll();
+  }
+
+  public void assertFiltersMutationsMatching(Predicate<MutationDetails> match, Class<?> clazz) {
+    final Sample s = makeSampleForCurrentCompiler(clazz);
+
+    final SoftAssertions softly = new SoftAssertions();
+    GregorMutater mutator = mutateFromClassLoader();
+
+    assertFiltersMatchingMutants(match, mutator, s, softly);
+
+    softly.assertAll();
+  }
+
+  public void assertFiltersMutationsMatching(Predicate<MutationDetails> match, String sample) {
+    final GregorMutater mutator = mutateFromResourceDir();
+    atLeastOneSampleExists(sample);
+
+    final SoftAssertions softly = new SoftAssertions();
+
+    for (final Sample s : samples(sample)) {
+      assertFiltersMatchingMutants(match, mutator, s, softly);
+    }
+
+    softly.assertAll();
+  }
+
+  private void assertFiltersMatchingMutants(Predicate<MutationDetails> match, GregorMutater mutator, Sample s, SoftAssertions softly) {
+    final List<MutationDetails> mutations = mutator.findMutations(s.className);
+    final Collection<MutationDetails> actual = filter(s.clazz, mutations, mutator);
+
+    checkHasMutantsMatching(match, s, softly, mutations);
+
+    softly.assertThat(actual)
+            .describedAs("Expected to filter out all matching mutants")
+            .noneMatch(match);
+  }
+
+  private void assertFiltersNoMatchingMutants(Predicate<MutationDetails> match, GregorMutater mutator, Sample s, SoftAssertions softly) {
+    final List<MutationDetails> mutations = mutator.findMutations(s.className);
+    final Collection<MutationDetails> actual = filter(s.clazz, mutations, mutator);
+
+    checkHasMutantsMatching(match, s, softly, mutations);
+
+    softly.assertThat(actual)
+            .describedAs("Expected to filter no matching mutants")
+            .anyMatch(match);
+  }
+
   private Sample makeSampleForCurrentCompiler(Class<?> clazz) {
     final ClassloaderByteArraySource source = ClassloaderByteArraySource.fromContext();
     final Sample s = new Sample();
@@ -163,6 +220,7 @@ private Predicate<MutationDetails> notIn(
     return a -> !actual.contains(a);
   }
 
+
   private void assertFiltersNMutants(int n, GregorMutater mutator, Sample s, SoftAssertions softly) {
     final List<MutationDetails> mutations = mutator.findMutations(s.className);
     final Collection<MutationDetails> actual = filter(s.clazz, mutations, mutator);
@@ -188,6 +246,12 @@ private void checkHasNMutants(int n, Sample s, SoftAssertions softly,
     .isGreaterThanOrEqualTo(n);
   }
 
+  private void checkHasMutantsMatching(Predicate<MutationDetails> match, Sample s, SoftAssertions softly,
+                                List<MutationDetails> mutations) {
+    softly.assertThat(mutations)
+            .describedAs("No matching mutations produced with " + s.compiler + " compiler. This test has a bug in it.\n" + s.clazz)
+            .anyMatch(match);
+  }
   private GregorMutater mutateFromResourceDir() {
     return new GregorMutater(this.source, m -> true, this.mutators);
   }