private static Function<MutationDetails, ClassName> byClass() { return a -> a.getClassName(); }
public ClassName getMutatedClass() { return this.mutations.iterator().next().getDetails().getClassName(); }
@Override public List<TestInfo> assignTests(MutationDetails mutation) { return prioritizeTests(mutation.getClassName(), pickTests(mutation)); }
private boolean killingTestHasNotChanged(final MutationDetails each, final MutationStatusTestPair mutationStatusTestPair) { final Collection<TestInfo> allTests = this.coverage.getTestsForClass(each .getClassName()); final List<ClassName> testClasses = allTests.stream() .filter(testIsCalled(mutationStatusTestPair.getKillingTest().get())) .map(TestInfo.toDefiningClassName()) .collect(Collectors.toList()); if (testClasses.isEmpty()) { return false; } return !this.history.hasClassChanged(testClasses.get(0)); }
public Collection<ClassMutationResults> toClassResults() { Collections.sort(this.mutations, comparator()); final List<ClassMutationResults> cmrs = new ArrayList<>(); final List<MutationResult> buffer = new ArrayList<>(); ClassName cn = null; for (final MutationResult each : this.mutations) { if ((cn != null) && !each.getDetails().getClassName().equals(cn)) { cmrs.add(new ClassMutationResults(buffer)); buffer.clear(); } cn = each.getDetails().getClassName(); buffer.add(each); } if (!buffer.isEmpty()) { cmrs.add(new ClassMutationResults(buffer)); } return cmrs; }
private Collection<TestInfo> pickTests(MutationDetails mutation) { if (!mutation.isInStaticInitializer()) { return this.coverage.getTestsForClassLine(mutation.getClassLine()); } else { LOG.warning("Using untargetted tests"); return this.coverage.getTestsForClass(mutation.getClassName()); } }
private static boolean isMutatedClass(final String name) { return (mutant != null) && mutant.getDetails().getClassName() .equals(ClassName.fromString(name)); }
private MutationStatusTestPair handleCoveredMutation( final MutationDetails mutationId, final Mutant mutatedClass, final List<TestUnit> relevantTests) { final MutationStatusTestPair mutationDetected; if (DEBUG) { LOG.fine("" + relevantTests.size() + " relevant test for " + mutatedClass.getDetails().getMethod()); } final Container c = createNewContainer(); final long t0 = System.currentTimeMillis(); if (this.hotswap.apply(mutationId.getClassName(), this.loader, mutatedClass.getBytes())) { if (DEBUG) { LOG.fine("replaced class with mutant in " + (System.currentTimeMillis() - t0) + " ms"); } mutationDetected = doTestsDetectMutation(c, relevantTests); } else { LOG.warning("Mutation " + mutationId + " was not viable "); mutationDetected = MutationStatusTestPair.notAnalysed(0, DetectionStatus.NON_VIABLE); } return mutationDetected; }
private Transformation createTransformation(final Mutant mutant) { return (name, bytes) -> { if (name.equals(mutant.getDetails().getClassName().asJavaName())) { return mutant.getBytes(); } else { return bytes; } }; }
@Override public void handleMutationResult(final ClassMutationResults metaData) { try { for (final MutationResult mutation : metaData.getMutations()) { this.out.write(makeCsv(mutation.getDetails().getFilename(), mutation .getDetails().getClassName().asJavaName(), mutation.getDetails() .getMutator(), mutation.getDetails().getMethod(), mutation .getDetails().getLineNumber(), mutation.getStatus(), createKillingTestDesc(mutation.getKillingTest())) + System.getProperty("line.separator")); } } catch (final IOException ex) { throw Unchecked.translateCheckedException(ex); } }
private MutationResult analyseFromHistory(final MutationDetails each, final MutationStatusTestPair mutationStatusTestPair) { final ClassName clazz = each.getClassName(); if (this.history.hasClassChanged(clazz)) { return analyseFromScratch(each); } if (mutationStatusTestPair.getStatus() == DetectionStatus.TIMED_OUT) { return makeResult(each, DetectionStatus.TIMED_OUT); } if ((mutationStatusTestPair.getStatus() == DetectionStatus.KILLED) && killingTestHasNotChanged(each, mutationStatusTestPair)) { return makeResult(each, DetectionStatus.KILLED, mutationStatusTestPair .getKillingTests(), mutationStatusTestPair.getSucceedingTests()); } if ((mutationStatusTestPair.getStatus() == DetectionStatus.SURVIVED) && !this.history.hasCoverageChanged(clazz, this.coverage.getCoverageIdForClass(clazz))) { return makeResult(each, DetectionStatus.SURVIVED); } return analyseFromScratch(each); }
private static boolean isMutatedClass(final String name) { return (mutant != null) && mutant.getDetails().getClassName() .equals(ClassName.fromString(name)); }
private String makeMutationNode(final MutationResult mutation) { final MutationDetails details = mutation.getDetails(); return makeNode(clean(details.getFilename()), sourceFile) + makeNode(clean(details.getClassName().asJavaName()), mutatedClass) + makeNode(clean(details.getMethod().name()), mutatedMethod) + makeNode(clean(details.getId().getLocation().getMethodDesc()), methodDescription) + makeNode("" + details.getLineNumber(), lineNumber) + makeNode(clean(details.getMutator()), mutator) + makeNode("" + details.getFirstIndex(), index) + makeNode("" + details.getBlock(), block) + makeNodeWhenConditionSatisfied(!fullMutationMatrix, createKillingTestDesc(mutation.getKillingTest()), killingTest) + makeNodeWhenConditionSatisfied(fullMutationMatrix, createTestDesc(mutation.getKillingTests()), killingTests) + makeNodeWhenConditionSatisfied(fullMutationMatrix, createTestDesc(mutation.getSucceedingTests()), succeedingTests) + makeNode(clean(details.getDescription()), description); }
private MutationStatusTestPair handleCoveredMutation( final MutationDetails mutationId, final Mutant mutatedClass, final List<TestUnit> relevantTests) { final MutationStatusTestPair mutationDetected; if (DEBUG) { LOG.fine("" + relevantTests.size() + " relevant test for " + mutatedClass.getDetails().getMethod()); } final Container c = createNewContainer(); final long t0 = System.currentTimeMillis(); if (this.hotswap.apply(mutationId.getClassName(), this.loader, mutatedClass.getBytes())) { if (DEBUG) { LOG.fine("replaced class with mutant in " + (System.currentTimeMillis() - t0) + " ms"); } mutationDetected = doTestsDetectMutation(c, relevantTests); } else { LOG.warning("Mutation " + mutationId + " was not viable "); mutationDetected = MutationStatusTestPair.notAnalysed(0, DetectionStatus.NON_VIABLE); } return mutationDetected; }
public static String methodKey(MutationResult mutation) { String className = mutation.getDetails().getClassName().asJavaName(); String methodName = mutation.getDetails().getMethod().name(); String methodDescription = mutation.getDetails().getId().getLocation().getMethodDesc(); return className + "." + methodName + methodDescription; }
report.writeAttribute("name", method); report.writeAttribute("description", methodDescription); report.writeAttribute("class", details.getClassName().getNameWithoutPackage().asJavaName()); report.writeAttribute("package", details.getClassName().getPackage().asJavaName()); report.endObject();
private String makeMutationNode(MutationResult mutation) { MutationDetails details = mutation.getDetails(); return makeNode(clean(details.getFilename()), Tag.sourceFile) + makeNode(clean(details.getClassName().asJavaName()), Tag.mutatedClass) + makeNode(clean(details.getMethod().name()), Tag.mutatedMethod) + makeNode(clean(details.getId().getLocation().getMethodDesc()), Tag.methodDescription) + makeNode("" + details.getLineNumber(), Tag.lineNumber) + makeNode(clean(details.getMutator()), Tag.mutator) + makeNode("" + details.getFirstIndex(), Tag.index) + makeNode(createKillingTestDesc(mutation.getKillingTest()), Tag.killingTest) + makeTestInfoNode(details) + makeNode(clean(details.getDescription()), Tag.description); }