mutate delayed execution code stored in statics

pitest-entry/src/main/java/org/pitest/mutationtest/build/intercept/staticinitializers/StaticInitializerInterceptor.java

@@ -1,6 +1,9 @@
 package org.pitest.mutationtest.build.intercept.staticinitializers;
 
 import org.objectweb.asm.Handle;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
 import org.objectweb.asm.tree.InvokeDynamicInsnNode;
 import org.objectweb.asm.tree.MethodInsnNode;
 import org.pitest.bytecode.analysis.ClassTree;
@@ -11,20 +14,33 @@
 import org.pitest.mutationtest.engine.Location;
 import org.pitest.mutationtest.engine.Mutater;
 import org.pitest.mutationtest.engine.MutationDetails;
+import org.pitest.sequence.Context;
+import org.pitest.sequence.Match;
+import org.pitest.sequence.QueryParams;
+import org.pitest.sequence.QueryStart;
+import org.pitest.sequence.SequenceMatcher;
+import org.pitest.sequence.Slot;
+import org.pitest.sequence.SlotWrite;
 
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static org.pitest.bytecode.analysis.InstructionMatchers.anyInstruction;
+import static org.pitest.bytecode.analysis.InstructionMatchers.isA;
+import static org.pitest.bytecode.analysis.InstructionMatchers.notAnInstruction;
+import static org.pitest.sequence.Result.result;
+
 /**
  * Identifies and marks mutations in code that is active during class
  * Initialisation.
@@ -39,6 +55,21 @@
  */
 class StaticInitializerInterceptor implements MutationInterceptor {
 
+ static final Slot<AbstractInsnNode> START = Slot.create(AbstractInsnNode.class);
+
+ static final SequenceMatcher<AbstractInsnNode> DELAYED_EXECUTION = QueryStart
+ .any(AbstractInsnNode.class)
+ .then(isA(MethodInsnNode.class).or(isA(InvokeDynamicInsnNode.class)).and(store(START.write())))
+ .then(storeToDeferredExecitionField())
+ .zeroOrMore(QueryStart.match(anyInstruction()))
+ .compile(QueryParams.params(AbstractInsnNode.class)
+ .withIgnores(notAnInstruction())
+ );
+
+ private static Match<AbstractInsnNode> storeToDeferredExecitionField() {
+ return (c,n) -> result(n.getOpcode() == Opcodes.PUTSTATIC && ((FieldInsnNode) n).desc.startsWith("Ljava/util/function/"), c);
+ }
+
  private Predicate<MutationDetails> isStaticInitCode;
 
  @Override
@@ -73,12 +104,15 @@ private void analyseClass(ClassTree tree) {
  .map(MethodTree::asLocation)
  .collect(Collectors.toSet());
 
+ Set<Call> storedToSupplier = findsCallsStoredToSuppliers(tree);
+
  // Get map of each private method to the private methods it calls
  // Any call to a no private method breaks the chain
  Map<Location, List<Call>> callTree = tree.methods().stream()
  .filter(m -> m.isPrivate() || m.rawNode().name.equals("<clinit>"))
  .flatMap(m -> allCallsFor(tree, m).stream().map(c -> new Call(m.asLocation(), c)))
  .filter(c -> privateMethods.contains(c.to()))
+ .filter(c -> !storedToSupplier.contains(c))
  .collect(Collectors.groupingBy(Call::from));
 
  Set<Location> visited = new HashSet<>();
@@ -89,12 +123,24 @@ private void analyseClass(ClassTree tree) {
  }
  }
 
+ private Set<Call> findsCallsStoredToSuppliers(ClassTree tree) {
+ return tree.methods().stream()
+ .filter(m -> m.isPrivate() || m.rawNode().name.equals("<clinit>"))
+ .flatMap(m -> delayedExecutionCall(m).stream().map(c -> new Call(m.asLocation(), c)))
+ .collect(Collectors.toSet());
+ }
+
+ private List<Location> delayedExecutionCall(MethodTree method) {
+ Context context = Context.start();
+ return DELAYED_EXECUTION.contextMatches(method.instructions(), context).stream()
+ .map(c -> c.retrieve(START.read()).get())
+ .flatMap(this::nodeToLocation)
+ .collect(Collectors.toList());
+ }
+
  private List<Location> allCallsFor(ClassTree tree, MethodTree m) {
- // temporarily disable dynamic calls as they are more likely to be involved
- // in storing delayed execution code within static fields.
- return callsFor(tree,m).collect(Collectors.toList());
- // return Stream.concat(callsFor(tree,m), invokeDynamicCallsFor(tree,m))
- // .collect(Collectors.toList());
+ return Stream.concat(callsFor(tree,m), invokeDynamicCallsFor(tree,m))
+ .collect(Collectors.toList());
  }
 
  private Stream<Location> callsFor(ClassTree tree, MethodTree m) {
@@ -123,6 +169,18 @@ private void visit(Map<Location, List<Call>> callTree, Set<Location> visited, Lo
  }
  }
 
+ private Stream<Location> nodeToLocation(AbstractInsnNode n) {
+ if (n instanceof MethodInsnNode) {
+ return Stream.of(asLocation((MethodInsnNode) n));
+ }
+
+ if (n instanceof InvokeDynamicInsnNode) {
+ return asLocation((InvokeDynamicInsnNode) n);
+ }
+
+ return Stream.empty();
+ }
+
  private Location asLocation(MethodInsnNode call) {
  return Location.location(ClassName.fromString(call.owner), call.name, call.desc);
  }
@@ -166,6 +224,10 @@ public InterceptorType type() {
  return InterceptorType.FILTER;
  }
 
+ private static Match<AbstractInsnNode> store(SlotWrite<AbstractInsnNode> slot) {
+ return (c, n) -> result(true, c.store(slot, n));
+ }
+
 }
 
 class Call {
@@ -184,4 +246,21 @@ Location from() {
  Location to() {
  return to;
  }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ Call call = (Call) o;
+ return Objects.equals(from, call.from) && Objects.equals(to, call.to);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(from, to);
+ }
 }

pitest-entry/src/test/java/com/example/staticinitializers/StaticFunctionField.java

@@ -0,0 +1,14 @@
+package com.example.staticinitializers;
+
+import java.util.function.Function;
+
+public class StaticFunctionField {
+ private static final Function<String,String> FOO = canMutate();
+
+ private static Function<String, String> canMutate() {
+ // don't mutate
+ System.out.println("ideally would mutate me");
+
+ return s -> s + "foo";
+ }
+}

pitest-entry/src/test/java/com/example/staticinitializers/StaticSupplierField.java

@@ -0,0 +1,14 @@
+package com.example.staticinitializers;
+
+import java.util.function.Supplier;
+
+public class StaticSupplierField {
+ final static Supplier<String> SUPPLER = canMutate();
+
+ private static Supplier<String> canMutate() {
+ // don't mutate
+ System.out.println("ideally would mutate me");
+
+ return () -> "Do not mutate"; // mutate
+ }
+}

pitest-entry/src/test/java/org/pitest/mutationtest/build/intercept/staticinitializers/StaticInitializerInterceptorTest.java

@@ -6,6 +6,8 @@
 import com.example.staticinitializers.NestedEnumWithLambdaInStaticInitializer;
 import com.example.staticinitializers.SecondLevelPrivateMethods;
 import com.example.staticinitializers.SingletonWithWorkInInitializer;
+import com.example.staticinitializers.StaticFunctionField;
+import com.example.staticinitializers.StaticSupplierField;
 import com.example.staticinitializers.ThirdLevelPrivateMethods;
 import org.junit.Ignore;
 import org.junit.Test;
@@ -146,7 +148,6 @@ public void analysisDoesNotGetStuckInInfiniteLoop() {
  }
 
  @Test
- @Ignore("temporally disabled while filtering reworked")
  public void filtersMutantsInEnumPrivateMethodsCalledViaMethodRef() {
  v.forClass(EnumWithLambdaInConstructor.class)
  .forMutantsMatching(inMethodStartingWith("doStuff"))
@@ -156,7 +157,6 @@ public void filtersMutantsInEnumPrivateMethodsCalledViaMethodRef() {
  }
 
  @Test
- @Ignore("temporally disabled while filtering reworked")
  public void filtersMutantsInLambdaCalledFromStaticInitializerInNestedEnum() {
  v.forClass(NestedEnumWithLambdaInStaticInitializer.TOYS.class)
  .forMutantsMatching(inMethodStartingWith("lambda"))
@@ -165,6 +165,26 @@ public void filtersMutantsInLambdaCalledFromStaticInitializerInNestedEnum() {
  .verify();
  }
 
+ @Test
+ public void doesNotSuppressDownStreamMutationsForCodeStoredInSuppliers() {
+ v.forClass(StaticSupplierField.class)
+ .forMethod("canMutate")
+ .forAnyCode()
+ .mutantsAreGenerated()
+ .noMutantsAreFiltered()
+ .verify();
+ }
+
+ @Test
+ public void doesNotSuppressDownStreamMutationsForCodeStoredInFunctions() {
+ v.forClass(StaticFunctionField.class)
+ .forMethod("canMutate")
+ .forAnyCode()
+ .mutantsAreGenerated()
+ .noMutantsAreFiltered()
+ .verify();
+ }
+
  private Predicate<MutationDetails> inMethod(String name, String desc) {
  return m -> m.getMethod().equals(name) && m.getId().getLocation().getMethodDesc().equals(desc);
  }