org.pitest.mutationtest.build.MutationInterceptor Java Examples

@Override
public MutationInterceptor createInterceptor(InterceptorParameters interceptorParameters) {
    Set<String> matchers = availabeMatchers.keySet();
    List<String> exclusions = interceptorParameters.getList(EXCEPT);
    if(exclusions != null)
        matchers.removeAll(exclusions);

    return new StopMethodInterceptor(
            StopMethodMatcher.any(
                    matchers.stream()
                            .map(key -> availabeMatchers.get(key))
                            .collect(Collectors.toList())
            )
    );

}
 

private List<MutationAnalysisUnit> buildMutationTests(
    final CoverageDatabase coverageData, final MutationEngine engine, EngineArguments args) {

  final MutationConfig mutationConfig = new MutationConfig(engine, coverage()
      .getLaunchOptions());

  final ClassByteArraySource bas = fallbackToClassLoader(new ClassPathByteArraySource(
      this.data.getClassPath()));

  final TestPrioritiser testPrioritiser = this.settings.getTestPrioritiser()
      .makeTestPrioritiser(this.data.getFreeFormProperties(), this.code,
          coverageData);

  final MutationInterceptor interceptor = this.settings.getInterceptor()
      .createInterceptor(this.data, bas);

  final MutationSource source = new MutationSource(mutationConfig, testPrioritiser, bas, interceptor);

  final MutationAnalyser analyser = new IncrementalAnalyser(
      new DefaultCodeHistory(this.code, history()), coverageData);

  final WorkerFactory wf = new WorkerFactory(this.baseDir, coverage()
      .getConfiguration(), mutationConfig, args,
      new PercentAndConstantTimeoutStrategy(this.data.getTimeoutFactor(),
          this.data.getTimeoutConstant()), this.data.isVerbose(), this.data.isFullMutationMatrix(),
          this.data.getClassPath().getLocalClassPath());

  final MutationGrouper grouper = this.settings.getMutationGrouper().makeFactory(
      this.data.getFreeFormProperties(), this.code,
      this.data.getNumberOfThreads(), this.data.getMutationUnitSize());
  final MutationTestBuilder builder = new MutationTestBuilder(wf, analyser,
      source, grouper);

  return builder.createMutationTestUnits(this.code.getCodeUnderTestNames());
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  if (params.data().isDetectInlinedCode()) {
    return new InlinedFinallyBlockFilter();
  }
  return CompoundMutationInterceptor.nullInterceptor();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new CompoundMutationInterceptor(Arrays.asList(new PrimitiveEquivalentFilter(),
      new NullReturnsFilter(),
      new EmptyReturnsFilter(),
      new HardCodedTrueEquivalentFilter())) {
    @Override
    public InterceptorType type() {
      return InterceptorType.FILTER;
    }
  };
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  final Optional<Integer> max = params.getInteger(this.limit);
  if (!max.isPresent()) {
    throw new IllegalArgumentException("Max mutation per class filter requires a limit parameter");
  }
  return new LimitNumberOfMutationPerClassFilter(max.get());
}
 

private MutationInterceptor getInterceptor(String... exclusions) throws IOException {
    StopMethodMatcherInterceptorFactory stopFactory = new StopMethodMatcherInterceptorFactory();
    Feature feature = stopFactory.provides();
    Map<String, List<String>> featureParameters = new HashMap<>();
    featureParameters.put("except", Arrays.asList(exclusions));
    FeatureSetting setting = new FeatureSetting(feature.name(), ToggleStatus.ACTIVATE, featureParameters);
    InterceptorParameters params = new InterceptorParameters(setting, null, null);
    return stopFactory.createInterceptor(params);
}
 

@Test
public void shouldFindOnlyNullableMethods() throws IOException {
    Class<?> target = loadClass("tests.PersonKt");
    Collection<MutationDetails> mutationPoints = findMutationPoints(target, "null");
    MutationInterceptor interceptor = getInterceptor();
    interceptor.begin(getClassTree(target));
    Collection<MutationDetails> filteredMutations = interceptor.intercept(mutationPoints, null);
    Collection<String> methods = filteredMutations.stream().map(details -> details.getMethod().name()).collect(Collectors.toList());
    assertThat(methods, contains("getPossiblyNullString"));
}
 

private MutationInterceptor getInterceptor() {
    AvoidNullInNotNullInterceptorFactory factory = new AvoidNullInNotNullInterceptorFactory();
    Feature feature = factory.provides();
    FeatureSetting setting = new FeatureSetting(feature.name(), ToggleStatus.ACTIVATE, Collections.emptyMap());
    InterceptorParameters params = new InterceptorParameters(setting, null, null);
    return new AvoidNullInNotNullInterceptorFactory().createInterceptor(params);
}
 

public FilterTester(String path, MutationInterceptor testee, MethodMutatorFactory ... mutators) {
  this(path, testee, Arrays.asList(mutators));
}
 

public FilterTester(String path, MutationInterceptor testee, Collection<MethodMutatorFactory> mutators) {
  this.mutators = mutators;
  this.testee = testee;
  this.path = path;
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new ExcludedAnnotationInterceptor(determineAnnotations(params));
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new KotlinFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new EqualsPerformanceShortcutFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters interceptorParameters) {
  return new KotlinInterceptor();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new AvoidForLoopCounterFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new InfiniteForLoopFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new InfiniteIteratorLoopFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new TryWithResourcesFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new ForEachLoopFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
    return new EnumConstructorFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new ImplicitNullCheckFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new MethodReferenceNullCheckFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new LoggingCallsFilter(params.data().getLoggingClasses());
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new StaticInitializerInterceptor();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new StaticInitializerFilter();
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters params) {
  return new MutantExportInterceptor(FileSystems.getDefault(), params.source(), params.data().getReportDir());
}
 

private Collection<MutationDetails> filteredMutations(Class<?> target, String... exclusions) throws IOException {
    MutationInterceptor interceptor = getInterceptor(exclusions);
    interceptor.begin(getClassTree(target));
    return interceptor.intercept(findMutationPoints(target), null);
}
 

@Override
public MutationInterceptor createInterceptor(InterceptorParameters interceptorParameters) {
    return new AvoidNullInNotNullInterceptor();
}
 

private void createEngineAndRun(final ReportOptions data,
    final JavaAgent agent,
    final Collection<String> mutators) {

  // data.setConfiguration(this.config);
  final CoverageOptions coverageOptions = createCoverageOptions(data);

  final LaunchOptions launchOptions = new LaunchOptions(agent,
      new DefaultJavaExecutableLocator(), data.getJvmArgs(),
      new HashMap<String, String>());

  final PathFilter pf = new PathFilter(
      Prelude.not(new DefaultDependencyPathPredicate()),
      Prelude.not(new DefaultDependencyPathPredicate()));
  final ProjectClassPaths cps = new ProjectClassPaths(data.getClassPath(),
      data.createClassesFilter(), pf);

  final Timings timings = new Timings();
  final CodeSource code = new CodeSource(cps);

  final CoverageGenerator coverageGenerator = new DefaultCoverageGenerator(
      null, coverageOptions, launchOptions, code, new NullCoverageExporter(),
      timings, false);

  final CoverageDatabase coverageData = coverageGenerator.calculateCoverage();

  final Collection<ClassName> codeClasses = FCollection.map(code.getCode(),
      ClassInfo.toClassName());

  final EngineArguments arguments = EngineArguments.arguments()
      .withMutators(mutators);

  final MutationEngine engine = new GregorEngineFactory().createEngine(arguments);

  final MutationConfig mutationConfig = new MutationConfig(engine,
      launchOptions);

  final ClassloaderByteArraySource bas = new ClassloaderByteArraySource(
      IsolationUtils.getContextClassLoader());

  final MutationInterceptor emptyIntercpetor = CompoundMutationInterceptor.nullInterceptor();

  final MutationSource source = new MutationSource(mutationConfig, new DefaultTestPrioritiser(
          coverageData), bas, emptyIntercpetor);


  final WorkerFactory wf = new WorkerFactory(null,
      coverageOptions.getPitConfig(), mutationConfig, arguments,
      new PercentAndConstantTimeoutStrategy(data.getTimeoutFactor(),
          data.getTimeoutConstant()), data.isVerbose(), false, data.getClassPath()
          .getLocalClassPath());




  final MutationTestBuilder builder = new MutationTestBuilder(wf,
      new NullAnalyser(), source, new DefaultGrouper(0));

  final List<MutationAnalysisUnit> tus = builder
      .createMutationTestUnits(codeClasses);

  this.mae.run(tus);
}