@Override public MutationInterceptor createInterceptor(InterceptorParameters params) { return new ForEachLoopFilter(); }
@Override public MutationInterceptor createInterceptor(InterceptorParameters params) { return new ImplicitNullCheckFilter(); }
@Override public MutationInterceptor createInterceptor(InterceptorParameters params) { return new TryWithResourcesFilter(); }
public void assertFiltersNMutationFromSample(int n, String sample) { final GregorMutater mutator = mutateFromResourceDir(); atLeastOneSampleExists(sample); final SoftAssertions softly = new SoftAssertions(); for (final Sample s : samples(sample)) { assertFiltersNMutants(n, mutator, s, softly); } softly.assertAll(); }
@Test public void shouldNotCombineMutationsWhenMoreThanOneInAHandlerBlock() { final int line = 100; final String mutator = "foo"; final int block = 1000; final List<MutationDetails> mutations = Arrays.asList( makeMutantInHandlerBlock(line, block, mutator, 0), makeMutantInHandlerBlock(line, block, mutator, 2), makeMutant(line, block + 1, mutator, 1)); final Collection<MutationDetails> actual = this.testee.intercept(mutations, this.unused); assertEquals(mutations, actual); }
public void assertFiltersMutationAtNLocations(int n, Class<?> clazz) { final Sample s = makeSampleForCurrentCompiler(clazz); assertFiltersMutationAtNLocations(n, s, mutateFromClassLoader()); }
@Test public void filtersMutationsToForEachOverField() { this.verifier = new FilterTester(PATH, this.testee, NonVoidMethodCallMutator.NON_VOID_METHOD_CALL_MUTATOR); // can mutate calls to iterator, hasNext and next this.verifier.assertFiltersNMutationFromClass(3, HasForEachLoopOverField.class); }
@Test public void doesNotFilterMutationsToIndexedForLoopJumps() { this.verifier = new FilterTester("forloops/{0}_{1}", this.testee, NegateConditionalsMutator.NEGATE_CONDITIONALS_MUTATOR); this.verifier.assertFiltersNMutationFromSample(0, "HasAForLoop"); }
public void assertFiltersNMutationFromClass(int n, Class<?> clazz) { final Sample s = makeSampleForCurrentCompiler(clazz); final SoftAssertions softly = new SoftAssertions(); assertFiltersNMutants(n, mutateFromClassLoader(), s, softly); softly.assertAll(); }
@Test public void shouldNotCombineMutantsWhenOnSameLineAndBlock() { final int line = 100; final int block = 1; final String mutator = "foo"; final List<MutationDetails> mutations = Arrays.asList( makeMutant(line, block, mutator, 0), makeMutant(line, block, mutator, 1)); assertEquals(mutations, this.testee.intercept(mutations, this.unused)); }
@Test public void doesNotFilterMutationsToHandRolledIteratorLoops() { // additional label nodes seem to be enough to prevent triggering this.verifier.assertFiltersNMutationFromSample(0, "HandRolledIteratorLoop"); }
@Override public void visitLineNumber(int line, Label start) { prepareToStartTracking(); this.currentLineNumber = line; super.visitLineNumber(line, start); }
@Test public void filtersEquivalentOptionalMutants() { verifier.assertFiltersNMutationFromClass(1, AlreadyReturnsEmptyOptional.class); } }
@Test public void shouldCreateSingleMutantWhenSameMutationCreatedOnSameLineInDifferentBlocksAndOneIsInAHandlerBlock() { final int line = 100; final String mutator = "foo"; final int block = 1000; final List<MutationDetails> mutations = Arrays.asList( makeMutantInHandlerBlock(line, block, mutator, 0), makeMutant(line, block + 1, mutator, 1)); assertEquals( Arrays.asList(makeMutantInHandlerBlock(line, block, mutator, Arrays.asList(0, 1))), this.testee.intercept(mutations, this.unused)); }
@Test public void filtersMutationsToForEachOverMethodReturn() { this.verifier = new FilterTester(PATH, this.testee, NonVoidMethodCallMutator.NON_VOID_METHOD_CALL_MUTATOR); // can mutate calls to iterator, hasNext and next this.verifier.assertFiltersNMutationFromClass(3, HasForEachLoopOverMethodReturn.class); }
@Test public void filtersMutationsToForEachLoopJumps() { this.verifier = new FilterTester(PATH, this.testee, NegateConditionalsMutator.NEGATE_CONDITIONALS_MUTATOR); this.verifier.assertFiltersNMutationFromSample(1, "HasForEachLoop"); }
@Test public void shouldNotCombineMutantsWhenOnSameLineAndDifferentBlocksButFromDifferentMutators() { final int line = 100; final int block = 1; final List<MutationDetails> mutations = Arrays.asList( makeMutant(line, block, "Foo", 0), makeMutant(line, block + 1, "NotFoo", 1)); assertEquals(mutations, this.testee.intercept(mutations, this.unused)); }
@Test public void filtersMutationsToForEachOverArrays() { // arrayLength, IConst, Jump, IINC this.verifier.assertFiltersNMutationFromSample(4, "HasForEachLoopOverArray"); }
@Test public void filtersMutationsToForEachOverCollections() { this.verifier = new FilterTester(PATH, this.testee, NonVoidMethodCallMutator.NON_VOID_METHOD_CALL_MUTATOR); // can mutate calls to iterator, hasNext and next this.verifier.assertFiltersNMutationFromClass(3, HasForEachLoopOverCollection.class); }
@Test public void filtersMutationsToHasNextAndNext() { this.verifier = new FilterTester(PATH, this.testee, NonVoidMethodCallMutator.NON_VOID_METHOD_CALL_MUTATOR); // can mutate calls to iterator, hasNext and next this.verifier.assertFiltersNMutationFromSample(3, "HasForEachLoop"); }