@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()); }
public List<MutationAnalysisUnit> createMutationTestUnits( final Collection<ClassName> codeClasses) { final List<MutationAnalysisUnit> tus = new ArrayList<>(); final List<MutationDetails> mutations = FCollection.flatMap(codeClasses, classToMutations()); Collections.sort(mutations, comparator()); final Collection<MutationResult> analysedMutations = this.analyser .analyse(mutations); final Collection<MutationDetails> needAnalysis = analysedMutations.stream() .filter(statusNotKnown()) .map(resultToDetails()) .collect(Collectors.toList()); final List<MutationResult> analysed = FCollection.filter(analysedMutations, Prelude.not(statusNotKnown())); if (!analysed.isEmpty()) { tus.add(makePreAnalysedUnit(analysed)); } if (!needAnalysis.isEmpty()) { for (final Collection<MutationDetails> ms : this.grouper.groupMutations( codeClasses, needAnalysis)) { tus.add(makeUnanalysedUnit(ms)); } } Collections.sort(tus, new AnalysisPriorityComparator()); return tus; }
private MutationAnalysisUnit makeUnanalysedUnit( final Collection<MutationDetails> needAnalysis) { final Set<ClassName> uniqueTestClasses = new HashSet<>(); FCollection.flatMapTo(needAnalysis, mutationDetailsToTestClass(), uniqueTestClasses); return new MutationTestUnit(needAnalysis, uniqueTestClasses, this.workerFactory); }
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()); }
private void makeTesteeWithUnitSizeOf(int unitSize) { this.testee = new MutationTestBuilder(this.wf, new NullAnalyser(), this.source, new DefaultGrouper(unitSize)); }
final MutationTestBuilder builder = new MutationTestBuilder(wf, new NullAnalyser(), source, new DefaultGrouper(0)); .createMutationTestUnits(codeClasses);
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 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()); }
@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()); }