Java Code Examples for org.pitest.functional.FCollection#filter()

@SuppressWarnings("unchecked")
private List<File> getCompiledDirs(final MavenProject project)
    throws Exception {
  final List<String> sourceRoots = new ArrayList<>();
  for (final Object artifactObj : FCollection
      .filter(project.getPluginArtifactMap().values(), new DependencyFilter(
          new PluginServices(this.getClass().getClassLoader())))) {

    final Artifact artifact = (Artifact) artifactObj;
    sourceRoots.add(artifact.getFile().getAbsolutePath());
  }
  return convertToRootDirs(project.getTestClasspathElements(),
      Arrays.asList(project.getBuild().getOutputDirectory(),
          project.getBuild().getTestOutputDirectory()),
      sourceRoots);
}
 

@Override
public Mutant getMutation(final MutationIdentifier id) {

  final ClassContext context = new ClassContext();
  context.setTargetMutation(Optional.ofNullable(id));

  final Optional<byte[]> bytes = this.byteSource.getBytes(id.getClassName()
      .asJavaName());

  final ClassReader reader = new ClassReader(bytes.get());
  final ClassWriter w = new ComputeClassWriter(this.byteSource,
      this.computeCache, FrameOptions.pickFlags(bytes.get()));
  final MutatingClassVisitor mca = new MutatingClassVisitor(w, context,
      filterMethods(), FCollection.filter(this.mutators,
          isMutatorFor(id)));
  reader.accept(mca, ClassReader.EXPAND_FRAMES);

  final List<MutationDetails> details = context.getMutationDetails(context
      .getTargetMutation().get());

  return new Mutant(details.get(0), w.toByteArray());

}
 

private void checkForInlinedCode(final Collection<MutationDetails> combined,
    final Entry<LineMutatorPair, Collection<MutationDetails>> each) {

  final List<MutationDetails> mutationsInHandlerBlock = FCollection
      .filter(each.getValue(), isInFinallyHandler());
  if (!isPossibleToCorrectInlining(mutationsInHandlerBlock)) {
    combined.addAll(each.getValue());
    return;
  }

  final MutationDetails baseMutation = mutationsInHandlerBlock.get(0);
  final int firstBlock = baseMutation.getBlock();

  // check that we have at least on mutation in a different block
  // to the base one (is this not implied by there being only 1 mutation in
  // the handler ????)
  final List<Integer> ids = map(each.getValue(), mutationToBlock());
  if (ids.stream().anyMatch(not(isEqual(firstBlock)))) {
    combined.add(makeCombinedMutant(each.getValue()));
  } else {
    combined.addAll(each.getValue());
  }
}
 

@Override
public void verify(final CodeSource code) {
  final Collection<ClassInfo> codeClasses = FCollection.filter(code.getCode(), isNotSynthetic());

  if (hasMutableCode(codeClasses)) {
    checkAtLeastOneClassHasLineNumbers(codeClasses);
    codeClasses.forEach(throwErrorIfHasNoSourceFile());
  }
}
 

@Override
public Collection<MutationDetails> intercept(
    Collection<MutationDetails> mutations, Mutater m) {
  if(!isKotlinClass) {
    return mutations;
  }
  return FCollection.filter(mutations, isKotlinJunkMutation(currentClass).negate());
}
 

@Override
public Collection<MutationDetails> intercept(
    Collection<MutationDetails> mutations, Mutater m) {
  if (this.skipClass) {
    return Collections.emptyList();
  }

  return FCollection.filter(mutations, Prelude.not(this.annotatedMethodMatcher));
}
 

public Collection<String> extractCallDependenciesForPackages(
    final String clazz, final Predicate<String> targetPackages)
        throws IOException {
  final Set<String> allDependencies = extractCallDependencies(clazz,
      new IgnoreCoreClasses());
  return FCollection.filter(allDependencies,
      and(asJVMNamePredicate(targetPackages), notSuppliedClass(clazz)));
}
 

@Override
public Collection<MutationDetails> intercept(
    Collection<MutationDetails> mutations, Mutater m) {
 final List<MutationDetails> doNotTouch = FCollection.filter(mutations, inEqualsMethod().negate());
 if (doNotTouch.size() != mutations.size()) {
   final List<MutationDetails> inEquals = FCollection.filter(mutations, inEqualsMethod());
   final List<MutationDetails> filtered = filter(inEquals, m);
   doNotTouch.addAll(filtered);
 }
 return doNotTouch;
}
 

public Collection<String> extractCallDependenciesForPackages(
    final String clazz, final Predicate<String> targetPackages,
    final Predicate<DependencyAccess> doNotTraverse) throws IOException {
  final Set<String> allDependencies = extractCallDependencies(clazz,
      doNotTraverse);
  return FCollection.filter(allDependencies, targetPackages);
}
 

List<TestUnit> filterTestsByDependencyAnalysis(final List<TestUnit> tus) {
  if (this.analyser.getMaxDistance() < 0) {
    return tus;
  } else {
    return FCollection.filter(tus, isWithinReach());
  }
}
 

private InstantiationStrategy findInstantiationStrategy(final Class<?> clazz) {
  final List<InstantiationStrategy> strategies = FCollection.filter(
      this.instantiationStrategies, canInstantiate(clazz));
  if (strategies.isEmpty()) {
    throw new PitError("Cannot instantiate " + clazz);
  } else {
    return strategies.get(0);
  }
}
 

private Set<DependencyAccess> extractRelevantDependencies(final String clazz,
    final Predicate<DependencyAccess> filter) throws IOException {
  final List<DependencyAccess> dependencies = extract(clazz, filter);
  final Set<DependencyAccess> relevantDependencies = new TreeSet<>(
      equalDestinationComparator());
  FCollection.filter(dependencies, filter, relevantDependencies);
  return relevantDependencies;
}
 

public List<MutationAnalysisUnit> createMutationTestUnits(
    final Collection<ClassName> codeClasses) {
  final List<MutationAnalysisUnit> tus = new ArrayList<>();

  final List<MutationDetails> mutations = FCollection.flatMap(codeClasses,
      classToMutations());

  mutations.sort(comparing(MutationDetails::getId));

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

  tus.sort(new AnalysisPriorityComparator());
  return tus;
}
 

private Iterable<MutationResultListenerFactory> findListeners() {
  final Iterable<? extends MutationResultListenerFactory> listeners = this.plugins
      .findListeners();
  final Collection<MutationResultListenerFactory> matches = FCollection
      .filter(listeners, nameMatches(this.options.getOutputFormats()));
  if (matches.size() < this.options.getOutputFormats().size()) {
    throw new PitError("Unknown listener requested in "
        + String.join(",", this.options.getOutputFormats()));
  }
  return matches;
}
 

private Collection<Artifact> filteredDependencies() {
  return FCollection.filter(this.mojo.getPluginArtifactMap().values(),
      this.dependencyFilter);
}
 

@Override
public Collection<MutationDetails> intercept(
    Collection<MutationDetails> mutations, Mutater m) {
  return FCollection.filter(mutations, Prelude.not(mutatesIteratorLoopPlumbing()));
}
 

@Override
public Collection<MutationDetails> intercept(
    Collection<MutationDetails> mutations, Mutater m) {
  return FCollection.filter(mutations, Prelude.not(isEquivalent(m)));
}
 

public List<MutationDetails> getMutationDetails(final MutationIdentifier id) {
  return FCollection.filter(this.mutations, hasId(id));
}
 

private static void addLaunchJavaAgents(List<String> cmd) {
  final RuntimeMXBean rt = ManagementFactory.getRuntimeMXBean();
  final List<String> agents = FCollection.filter(rt.getInputArguments(),
      or(isJavaAgentParam(), isEnvironmentSetting()));
  cmd.addAll(agents);
}
 

@Override
public Collection<MutationDetails> intercept(
    Collection<MutationDetails> mutations, Mutater m) {
  return FCollection.filter(mutations, Prelude.not(isInStaticInitCode()));
}