private Function<ClassName, Iterable<MutationDetails>> classToMutations() { return a -> MutationTestBuilder.this.mutationSource.createMutations(a); }
@Before public void setUp() { when(this.engine.createMutator(any(ClassByteArraySource.class))).thenReturn(this.mutater); this.config = new MutationConfig(this.engine, new LaunchOptions(null)); this.testee = new MutationSource(this.config, this.prioritiser , this.source, CompoundMutationInterceptor.nullInterceptor()); }
public Collection<MutationDetails> createMutations(final ClassName clazz) { final Mutater m = this.mutationConfig.createMutator(this.source); final Collection<MutationDetails> availableMutations = m .findMutations(clazz); if (availableMutations.isEmpty()) { return availableMutations; } else { final ClassTree tree = ClassTree .fromBytes(this.source.getBytes(clazz.asJavaName()).get()); this.interceptor.begin(tree); final Collection<MutationDetails> updatedMutations = this.interceptor .intercept(availableMutations, m); this.interceptor.end(); assignTestsToMutations(updatedMutations); return updatedMutations; } }
MutationSource createSource(ClassByteArraySource source) { final SettingsFactory settings = new SettingsFactory(this.data, PluginServices.makeForContextLoader()); final MutationInterceptor interceptor = settings.getInterceptor() .createInterceptor(this.data, source); final MutationEngine engine = new GregorEngineFactory().createEngine( EngineArguments.arguments().withExcludedMethods(this.data.getExcludedMethods()) .withMutators(this.data.getMutators())); final MutationConfig config = new MutationConfig(engine, null); return new MutationSource(config, noTestPrioritisation(), source, interceptor); }
private Collection<MutationDetails> findMutants(ClassName clazz) { final MutationSource source = createSource(this.cbas); return source.createMutations(clazz); }
private List<MutationAnalysisUnit> buildMutationTests( final CoverageDatabase coverageData, final MutationEngine engine, EngineArguments args) { final MutationConfig mutationConfig = new MutationConfig(engine, coverage() .getLaunchOptions()); final ClassByteArraySource bas = fallbackToClassLoader(new ClassPathByteArraySource( this.data.getClassPath())); final TestPrioritiser testPrioritiser = this.settings.getTestPrioritiser() .makeTestPrioritiser(this.data.getFreeFormProperties(), this.code, coverageData); final MutationInterceptor interceptor = this.settings.getInterceptor() .createInterceptor(this.data, bas); final MutationSource source = new MutationSource(mutationConfig, testPrioritiser, bas, interceptor); final MutationAnalyser analyser = new IncrementalAnalyser( new DefaultCodeHistory(this.code, history()), coverageData); final WorkerFactory wf = new WorkerFactory(this.baseDir, coverage() .getConfiguration(), mutationConfig, args, new PercentAndConstantTimeoutStrategy(this.data.getTimeoutFactor(), this.data.getTimeoutConstant()), this.data.isVerbose(), this.data.isFullMutationMatrix(), this.data.getClassPath().getLocalClassPath()); final MutationGrouper grouper = this.settings.getMutationGrouper().makeFactory( this.data.getFreeFormProperties(), this.code, this.data.getNumberOfThreads(), this.data.getMutationUnitSize()); final MutationTestBuilder builder = new MutationTestBuilder(wf, analyser, source, grouper); return builder.createMutationTestUnits(this.code.getCodeUnderTestNames()); }
@Test public void shouldReturnNoMuationsWhenNoneFound() { assertEquals(Collections.emptyList(), this.testee.createMutations(this.foo)); }
final MutationSource source = new MutationSource(mutationConfig, new DefaultTestPrioritiser( coverageData), bas, emptyIntercpetor);
@Test public void shouldCreateNoUnitsWhenNoMutationsFound() { when(this.source.createMutations(any(ClassName.class))).thenReturn( Collections.<MutationDetails> emptyList()); assertTrue(this.testee.createMutationTestUnits( Arrays.asList(ClassName.fromString("foo"))).isEmpty()); }
private void assertCreatesOneTestUnitForTwoMutations() { final MutationDetails mutation1 = createDetails("foo"); final MutationDetails mutation2 = createDetails("foo"); when(this.source.createMutations(any(ClassName.class))).thenReturn( Arrays.asList(mutation1, mutation2)); final List<MutationAnalysisUnit> actual = this.testee .createMutationTestUnits(Arrays.asList(ClassName.fromString("foo"))); assertEquals(1, actual.size()); }
@Test public void shouldAssignTestsFromPrioritiserToMutant() { final List<TestInfo> expected = makeTestInfos(0); final List<MutationDetails> mutations = makeMutations("foo"); when(this.prioritiser.assignTests(any(MutationDetails.class))).thenReturn( expected); when(this.mutater.findMutations(any(ClassName.class))) .thenReturn(mutations); final MutationDetails actual = this.testee.createMutations(this.foo) .iterator().next(); assertEquals(expected, actual.getTestsInOrder()); }
@Test public void shouldOrderLargestUnitFirst() { final MutationDetails mutation1 = createDetails("foo"); final MutationDetails mutation2 = createDetails("bar"); final ClassName foo = ClassName.fromString("foo"); final ClassName bar = ClassName.fromString("bar"); when(this.source.createMutations(foo)).thenReturn(Arrays.asList(mutation1)); when(this.source.createMutations(bar)).thenReturn( Arrays.asList(mutation2, mutation2)); final List<MutationAnalysisUnit> actual = this.testee .createMutationTestUnits(Arrays.asList(foo, bar)); assertTrue(actual.get(0).priority() > actual.get(1).priority()); }
@Test public void shouldCreateMultipleTestUnitsWhenUnitSizeIsLessThanNumberOfMutations() { makeTesteeWithUnitSizeOf(1); when(this.source.createMutations(any(ClassName.class))).thenReturn( Arrays.asList(createDetails("foo"), createDetails("foo"), createDetails("foo"))); final List<MutationAnalysisUnit> actual = this.testee .createMutationTestUnits(Arrays.asList(ClassName.fromString("foo"))); assertEquals(3, actual.size()); }