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

protected void assertMutantsReturn(final Callable<String> mutee,
    final List<MutationDetails> details,
    final String... expectedResults) {

  final List<Mutant> mutants = this.getMutants(details);
  assertEquals("Should return one mutant for each request", details.size(),
      mutants.size());
  final List<String> results = FCollection.map(mutants,
      mutantToStringReults(mutee));

  int i = 0;
  for (final String actual : results) {
    assertEquals(expectedResults[i], actual);
    i++;
  }
}
 

@Override
protected void setUp() throws Exception {
  super.setUp();
  MockitoAnnotations.initMocks(this);
  this.classPath = new ArrayList<>(FCollection.map(
      ClassPath.getClassPathElementsAsFiles(), fileToString()));
  when(this.project.getTestClasspathElements()).thenReturn(this.classPath);
  when(this.project.getPackaging()).thenReturn("jar");
  
  final Build build = new Build();
  build.setOutputDirectory("");
  
  when(this.project.getBuild()).thenReturn(build);
  
  when(this.plugins.findToolClasspathPlugins()).thenReturn(
      Collections.emptyList());
  when(this.plugins.findClientClasspathPlugins()).thenReturn(
      Collections.emptyList());
}
 

private Function<Category, Iterable<String>> toCategoryNames() {
  return a -> {
    if (a == null) {
      return Collections.emptyList();
    }
    return FCollection.map(Arrays.asList(a.value()),toName());
  };
}
 

public SmartSourceLocator(final Collection<File> roots) {
  final Collection<File> childDirs = FCollection.flatMap(roots,
      collectChildren(0));
  childDirs.addAll(roots);

  final Function<File, SourceLocator> fileToSourceLocator = a -> new DirectorySourceLocator(a);
  this.children = FCollection.map(childDirs, fileToSourceLocator);
}
 

public ClassInfo(final ClassPointer superClass,
    final ClassPointer outerClass, final ClassInfoBuilder builder) {
  this.superClass = superClass;
  this.outerClass = outerClass;
  this.id = builder.id;
  this.access = builder.access;
  this.codeLines = builder.codeLines;
  this.annotations = FCollection.map(builder.annotations,
      ClassName.stringToClassName());
  this.sourceFile = builder.sourceFile;
  this.classAnnotationValues = builder.classAnnotationValues;
}
 

public MutationInterceptor createInterceptor(
    ReportOptions data,
    ClassByteArraySource source) {
  final List<MutationInterceptor> interceptors = FCollection.map(this.features.getActiveFeatures(),
      toInterceptor(this.features, data, source));
  return new CompoundMutationInterceptor(interceptors);
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
private List<File> convertToRootDirs(final List... directoryLists) {
  final List<String> roots = new ArrayList<>();
  for (final List directoryList : directoryLists) {
    roots.addAll(directoryList);
  }
  return FCollection.map(roots, new Function<String, File>() {
    @Override
    public File apply(final String a) {
      return new File(a);
    }
  });
}
 

private  static List<ClassPathRoot> wrapToAvoidIOOperations(
    List<ClassPathRoot> roots) {
  return FCollection.map(roots, NameCachingRoot.toCachingRoot());
}
 

public List<FeatureSetting> parseFeatures(Collection<String> config) {
  return FCollection.map(config, stringToSettings());
}
 

@Override
public Collection<MutationResult> analyse(
    final Collection<MutationDetails> mutationsForClasses) {
  return FCollection.map(mutationsForClasses, mutationToResult());
}
 

private List<TestInfo> makeTestInfos(final Integer... times) {
  return new ArrayList<>(FCollection.map(Arrays.asList(times),
      timeToTestInfo()));
}
 

private Collection<File> stringsTofiles(final List<String> sourceRoots) {
  return FCollection.map(sourceRoots, stringToFile());
}
 

private static Function<Entry<InstructionLocation, Set<TestInfo>>, BlockCoverage> toBlockCoverage() {
  return a -> new BlockCoverage(a.getKey().getBlockLocation(), FCollection.map(a.getValue(),
      TestInfo.toName()));
}
 

public List<BlockCoverage> createCoverage() {
  return FCollection.map(this.instructionCoverage.entrySet(), toBlockCoverage());
}
 

public static Collection<MethodMutatorFactory> byName(final String name) {
  return FCollection.map(MUTATORS.get(name),
      Prelude.id(MethodMutatorFactory.class));
}
 

private static Function<MutationDetails, Iterable<ClassName>> mutationDetailsToTestClass() {
  return a -> FCollection.map(a.getTestsInOrder(),
      TestInfo.toDefiningClassName());
}
 

@Override
public Collection<String> getMutatorNames() {
  return FCollection.map(this.mutationOperators, toName());
}
 

@Override
public MutationResultListener getListener(final Properties props,
    final ListenerArguments args) {
  return new CompoundTestListener(FCollection.map(this.children,
      factoryToListener(props, args)));
}
 

private void convertExcludes(ReportOptions option, Xpp3Dom configuration) {
  List<Predicate<String>> excludes = FCollection.map(
      extract("excludes", configuration), filenameToClassFilter());
  excludes.addAll(option.getExcludedTestClasses());
  option.setExcludedTestClasses(excludes);
}
 

private List<String> findModifiedClassNames() throws MojoExecutionException {

    final File sourceRoot = new File(this.getProject().getBuild()
        .getSourceDirectory());

    final List<String> modifiedPaths = FCollection.map(findModifiedPaths(), pathByScmDir());
    return FCollection.flatMap(modifiedPaths, new PathToJavaClassConverter(
            sourceRoot.getAbsolutePath()));

  }