public String describe() { return this.method.name(); }
private void analyseClass(ClassTree tree) { final Optional<MethodTree> clinit = tree.methods().stream().filter(nameEquals(CLINIT.name())).findFirst(); if (clinit.isPresent()) { final List<Predicate<MethodTree>> selfCalls = clinit.get().instructions().stream() .flatMap(is(MethodInsnNode.class)) .filter(calls(tree.name())) .map(toPredicate()) .collect(Collectors.toList()); final Predicate<MethodTree> matchingCalls = Prelude.or(selfCalls); final Predicate<MutationDetails> initOnlyMethods = Prelude.or(tree.methods().stream() .filter(isPrivateStatic()) .filter(matchingCalls) .map(AnalysisFunctions.matchMutationsInMethod()) .collect(Collectors.toList()) ); this.isStaticInitCode = Prelude.or(isInStaticInitializer(), initOnlyMethods); } }
@Override public boolean matches(MutationDetails value) { return value.getId().getLocation().getMethodName().name().equals(name); } };
@Test public void shouldFilterMethodsWithGeneratedAnnotation() { final List<MutationDetails> mutations = this.mutator.findMutations(ClassName.fromClass(MethodAnnotatedWithGenerated.class)); final Collection<MutationDetails> actual = runWithTestee(mutations, MethodAnnotatedWithGenerated.class); assertThat(actual).hasSize(1); assertThat(actual.iterator().next().getId().getLocation().getMethodName().name()).isEqualTo("bar"); }
private void assertOnlyClinitMethodsMarked(Collection<MutationDetails> actual) { for (final MutationDetails each : actual ) { if (each.isInStaticInitializer()) { if (!each.getId().getLocation().getMethodName().name().equals("<clinit>")) { fail("Expected no mutants to be marked as for static initialization but " + each + " was"); } } } }
public String describe() { return this.method.name(); }
private void writeLineCoverage(final BlockCoverage each, final Writer out) { final Location l = each.getBlock().getLocation(); write( out, "<block classname='" + l.getClassName().asJavaName() + "'" + " method='" + StringUtil.escapeBasicHtmlChars(l.getMethodName().name()) + StringUtil.escapeBasicHtmlChars(l.getMethodDesc()) + "' number='" + each.getBlock().getBlock() + "'>"); write(out, "<tests>\n"); final List<String> ts = new ArrayList<>(each.getTests()); Collections.sort(ts); for (final String test : ts) { write(out, "<test name='" + StringUtil.escapeBasicHtmlChars(test) + "'/>\n"); } write(out, "</tests>\n"); write(out, "</block>\n"); }
public String name() { return location.getMethodName().name(); }
private void updateStatus(DetectionStatus status) { if(status == DetectionStatus.NO_COVERAGE) { if(classification != NOT_COVERED) throw new IllegalArgumentException("Method " + location.getMethodName().name() + " has been marked as covered and can not accept a non-covered mutation."); return; } if(classification == NOT_COVERED) throw new IllegalArgumentException("Method " + location.getMethodName().name() + " has been marked as non-covered and can not accept a covered mutation"); if((status.isDetected() && classification == PSEUDO_TESTED) || (!status.isDetected() && classification == TESTED)) classification = PARTIALLY_TESTED; }
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); }
@Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { MethodVisitor methodVisitor = cv.visitMethod(access, name, desc, signature, exceptions); Location location = mID.getLocation(); if(location.getMethodDesc().equals(desc) && location.getMethodName().name().equals(name)) { return new MutationMethodAdapter( MutationOperator.fromID(mID.getMutator()), new Method(location.getMethodName().name(), location.getMethodDesc()), methodVisitor); } return methodVisitor; } }
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; }
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); }
String method = details.getMethod().name(); String methodDescription = details.getId().getLocation().getMethodDesc();