org.pitest.bytecode.analysis.ClassTree Java Examples

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);
  }
}
 

private List<Sample> samples(final String sample) {
  final Function<String, Stream<Sample>> toPair = compiler -> {
    final String clazz = makeClassName(sample, compiler);
    final Optional<byte[]> bs = FilterTester.this.source.getBytes(clazz);
    if (bs.isPresent()) {
      final Sample p = new Sample();
      p.className = ClassName.fromString(clazz);
      p.clazz = ClassTree.fromBytes(bs.get());
      p.compiler = compiler;
      return Stream.of(p);
    }
    return Stream.empty();

  };
  return COMPILERS.stream().flatMap(toPair).collect(Collectors.toList());
}
 

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;
    }
  }
 

private static Predicate<MutationDetails> isKotlinJunkMutation(final ClassTree currentClass) {
  return a -> {
      int instruction = a.getInstructionIndex();
      MethodTree method = currentClass.methods().stream()
          .filter(MethodMatchers.forLocation(a.getId().getLocation()))
          .findFirst()
          .get();
      AbstractInsnNode mutatedInstruction = method.instruction(instruction);
      Context<AbstractInsnNode> context = Context.start(method.instructions(), DEBUG);
      context.store(MUTATED_INSTRUCTION.write(), mutatedInstruction);
      return KOTLIN_JUNK.matches(method.instructions(), context);
  };
}
 

private Boolean shortCutEquals(MethodTree tree, MutationDetails a, Mutater m) {
  if (!mutatesAConditionalJump(tree, a.getInstructionIndex())) {
    return false;
  }

  final ClassTree mutant = ClassTree.fromBytes(m.getMutation(a.getId()).getBytes());
  final MethodTree mutantEquals = mutant.methods().stream()
      .filter(MethodMatchers.forLocation(tree.asLocation()))
      .findFirst()
      .get();

  return ALWAYS_FALSE.matches(mutantEquals.instructions());
}
 

@Override
public void begin(ClassTree clazz) {
  this.skipClass = clazz.annotations().stream()
      .filter(avoidedAnnotation())
      .findFirst().isPresent();
  if (!this.skipClass) {
    final List<Predicate<MutationDetails>> methods = clazz.methods().stream()
        .filter(hasAvoidedAnnotation())
        .map(AnalysisFunctions.matchMutationsInMethod())
        .collect(Collectors.toList());
    this.annotatedMethodMatcher = Prelude.or(methods);
  }
}
 

private boolean isInfiniteLoop(MutationDetails each, Mutater m) {
  final ClassTree mutantClass = ClassTree.fromBytes(m.getMutation(each.getId()).getBytes());
  final Optional<MethodTree> mutantMethod = mutantClass.methods().stream()
      .filter(forLocation(each.getId().getLocation()))
      .findFirst();
  return infiniteLoopMatcher().matches(mutantMethod.get().instructions());
}
 

@Test
public void shouldNotifyAllChildrenOfNewClass() {
  this.testee = new CompoundMutationInterceptor(Arrays.asList(this.modifyChild,this.filterChild));
  final ClassTree aClass = new ClassTree(null);

  this.testee.begin(aClass);
  verify(this.modifyChild).begin(aClass);
  verify(this.filterChild).begin(aClass);
}
 

@Override
public void begin(ClassTree clazz) {
  this.lines = new HashSet<>();
  for (final MethodTree each : clazz.methods()) {
    checkMehod(each,this.lines);
  }
}
 

private Function<MutationDetails, Loc> toLocation(final ClassTree tree) {
  return a -> {
    final MethodTree method = tree.method(a.getId().getLocation()).get();
    final Loc l = new Loc();
    l.index = a.getInstructionIndex();
    l.node = method.instruction(a.getInstructionIndex());
    return l;
  };
}
 

@Override
public void begin(ClassTree clazz) {
  this.lines = new HashSet<>();
  for (final MethodTree each : clazz.methods()) {
    findLoggingLines(each,this.lines);
  }
}
 

private Sample makeSampleForCurrentCompiler(Class<?> clazz) {
  final ClassloaderByteArraySource source = ClassloaderByteArraySource.fromContext();
  final Sample s = new Sample();
  s.className = ClassName.fromClass(clazz);
  s.clazz = ClassTree.fromBytes(source.getBytes(clazz.getName()).get());
  s.compiler = "current";
  return s;
}
 

private Collection<MutationDetails> filter(ClassTree clazz,
    List<MutationDetails> mutations, Mutater mutator) {
  this.testee.begin(clazz);
  final Collection<MutationDetails> actual = this.testee.intercept(mutations, mutator);
  this.testee.end();
  return actual;
}
 

@Test
public void shouldNotMatch() throws IOException {
    ClassTree classTree = getClassTree(getTargetClass());
    StopMethodMatcher matcher = getMatcher();
    classTree.methods().stream()
            .filter( method -> !criterion(method))
            .forEach(
                    method -> assertFalse("Incorrectly matched: " + method.rawNode().name, matcher.matches(classTree, method)));
}
 

@Test
public void shouldMatchMethods() throws IOException {

    ClassTree classTree = getClassTree(getTargetClass());
    StopMethodMatcher matcher = getMatcher();
    classTree.methods().stream()
            .filter(this::criterion)
            .forEach(
                    method -> assertTrue("Could not match method: " + method.rawNode().name, matcher.matches(classTree, method)));
}
 

@BeforeClass
public static void getClassTree() throws IOException {
    ClassReader reader = new ClassReader(StopMethods.class.getName());
    ClassNode classNode = new ClassNode();
    classTree = new ClassTree(classNode);
    reader.accept(classNode, 0);
}
 

public static ClassTree getClassTree(Class<?> target) throws IOException {
    org.objectweb.asm.ClassReader reader = new org.objectweb.asm.ClassReader(target.getName());
    org.objectweb.asm.tree.ClassNode classNode = new org.objectweb.asm.tree.ClassNode();
    ClassTree classTree = new ClassTree(classNode);
    reader.accept(classNode, 0);
    return classTree;
}
 

private Sample sampleForClass(Class<?> clazz) {
  final ClassloaderByteArraySource source = ClassloaderByteArraySource.fromContext();
  final Sample s = new Sample();
  s.className = ClassName.fromClass(clazz);
  s.clazz = ClassTree.fromBytes(source.getBytes(clazz.getName()).get());
  s.compiler = "current";
  return s;
}
 

@Override
public void begin(ClassTree clazz) {
  this.currentClass = clazz.name();
  final String[] classLocation = ("export." + clazz.name().asJavaName())
      .split("\\.");
  final Path classDir = this.fileSystem.getPath(this.outDir, classLocation);
  this.mutantsDir = classDir.resolve("mutants");
  try {
    Files.createDirectories(this.mutantsDir);
    writeBytecodeToDisk(this.source.getBytes(clazz.name().asJavaName()).get(), classDir);
  } catch (final IOException e) {
    throw new RuntimeException("Couldn't create direectory for " + clazz, e);
  }
}
 

private Optional<MethodTree> parseMethodFromCompiledResource(ClassName clazz,
    Compiler compiler, Predicate<MethodTree> method) {
  final ResourceFolderByteArraySource source = new ResourceFolderByteArraySource();
  final Optional<byte[]> bs = source.getBytes("loops/" + compiler.name() + "/" + clazz.getNameWithoutPackage().asJavaName());
  if (bs.isPresent()) {
    final ClassTree tree = ClassTree.fromBytes(bs.get());
    return tree.methods().stream().filter(method).findFirst();
  }
  return Optional.empty();
}
 

@Override
public void begin(ClassTree clazz) {
  currentClass = clazz;
  isKotlinClass = clazz.annotations().stream()
      .filter(annotationNode -> annotationNode.desc.equals("Lkotlin/Metadata;"))
      .findFirst()
      .isPresent();
}
 

@Override
public void begin(ClassTree clazz) {
  this.currentClass = clazz;
}
 

ClassTree treeFor(Class<?> clazz) {
  final ClassloaderByteArraySource source = ClassloaderByteArraySource.fromContext();
  return ClassTree.fromBytes(source.getBytes(clazz.getName()).get());
}
 

@Override
public void begin(ClassTree clazz) {
  // noop
}
 

ClassTree forClass(Class<?> clazz) {
  final byte[] bs = this.source.getBytes(clazz.getName()).get();
  return ClassTree.fromBytes(bs);
}
 

@Override
public void begin(ClassTree clazz) {
  this.children.forEach(each -> each.begin(clazz));
}
 

@Override
public void begin(ClassTree clazz) {
  // noop
}
 

private ClassTree tree(Class<?> clazz) {
  return ClassTree.fromBytes(this.source.getBytes(clazz.getName()).get());
}
 

ClassTree forClass(Class<?> clazz) {
  final byte[] bs = this.source.getBytes(clazz.getName()).get();
  return ClassTree.fromBytes(bs);
}
 

private ClassTree treeFor(Class<?> clazz) {
  final ClassloaderByteArraySource source = ClassloaderByteArraySource.fromContext();
  return ClassTree.fromBytes(source.getBytes(clazz.getName()).get());
}