org.pitest.plugin.Feature Java Examples

public void describeFeatures(Consumer<Feature> enabled, Consumer<Feature> disabled) {
  final FeatureParser parser = new FeatureParser();
  final Collection<ProvidesFeature> available = new ArrayList<>(this.plugins.findInterceptors());
  final List<FeatureSetting> settings = parser.parseFeatures(this.options.getFeatures());
  final FeatureSelector<ProvidesFeature> selector = new FeatureSelector<>(settings, available);

  List<Feature> enabledFeatures = selector.getActiveFeatures().stream()
    .map(toFeature())
    .distinct()
    .sorted(byName())
    .collect(Collectors.toList());
    
  enabledFeatures.forEach(enabled);

  available.stream()
    .map(toFeature())
    .distinct()
    .sorted(byName())
    .filter(f -> !enabledFeatures.contains(f))
    .forEach(disabled);
  
}
 

@Override
public Feature provides() {
    return Feature
            .named("STOP_METHODS")
            .withOnByDefault(true)
            .withDescription("Filters out mutations in methods that are generally of no interest")
            .withParameter(EXCEPT);

}
 

@Test
public void shouldDescribeDisabledFeatures() {
  final Consumer<Feature> disabled = Mockito.mock(Consumer.class);
  final Consumer<Feature> enabled = Mockito.mock(Consumer.class);

  this.options.setFeatures(Arrays.asList("-FSTATINIT"));

  this.testee.describeFeatures(enabled, disabled);
  verify(enabled, never()).accept(Feature.named("FSTATINIT"));
  verify(disabled).accept(Feature.named("FSTATINIT"));
}
 

@Test
public void shouldDescribeActiveFeatures() {
  final Consumer<Feature> disabled = Mockito.mock(Consumer.class);
  final Consumer<Feature> enabled = Mockito.mock(Consumer.class);

  this.options.setFeatures(Arrays.asList("+FSTATINIT"));

  this.testee.describeFeatures(enabled, disabled);
  verify(enabled).accept(Feature.named("FSTATINIT"));
  verify(disabled, never()).accept(Feature.named("FSTATINIT"));
}
 

@Override
public Feature provides() {
  return Feature.named("FANN")
      .withOnByDefault(true)
      .withDescription("Filters mutations in classes and methods with matching annotations of class or runtime retention")
      .withParameter(ARGUMENT);
}
 

@Override
public Feature provides() {
  return Feature.named("FRETEQUIV")
      .withOnByDefault(true)
      .withDescription("Filters return vals mutants with bytecode equivalent to the unmutated class");

}
 

@Override
public Feature provides() {
  return Feature.named("FINFIT")
      .withOnByDefault(true)
      .withDescription("Filters mutations that may cause infinite loops"
          + " by removing calls to iterator.next");
}
 

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

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

private Consumer<Feature> asInfo(final String leader) {
  return a -> {
    Log.getLogger().info(String.format("%1$-16s",leader + a.name()) + a.description());
    for (final FeatureParameter each : a.params()) {
      Log.getLogger().info(String.format("%1$-18s", "  [" + each.name() + "]") + each.description());
    }
  };
}
 

@Override
public Feature provides() {
  return Feature.named("FTRYWR")
      .withOnByDefault(true)
      .withDescription("Filters mutations in code generated for try with resources statements");
}
 

@Override
public Feature provides() {
  return Feature.named("KOTLIN")
    .withOnByDefault(true)
    .withDescription("Improves support of kotlin language");
}
 

@Override
public Feature provides() {
    return Feature.named("AVOID_NULL")
            .withDescription(DESCRIPTION)
            .withOnByDefault(true);
}
 

@Override
public Feature provides() {
  return Feature.named("CLASSLIMIT")
      .withDescription("Limits the maximum number of mutations per class")
      .withParameter(this.limit);
}
 

@Override
public Feature provides() {
  return Feature.named("FKOTLIN")
      .withDescription("Filters out junk mutations in bytecode created by compiler for kotlin language features")
      .withOnByDefault(true);
}
 

@Override
public Feature provides() {
  return Feature.named("FSEQUIVEQUALS")
      .withOnByDefault(true)
      .withDescription("Filters equivalent mutations that affect only performance in short cutting equals methods");
}
 

@Override
public Feature provides() {
  return Feature.named("FFLOOP")
      .withOnByDefault(true)
      .withDescription("Filters any mutations to increments in for loops as they may cause timeouts");
}
 

@Override
public Feature provides() {
  return Feature.named("FINFINC")
      .withOnByDefault(true)
      .withDescription("Filters mutations to increments that may cause infinite loops");
}
 

@Override
public Feature provides() {
  return Feature.named("EXPORT")
      .withDescription("Exports mutants bytecode and other details to disk")
      .withOnByDefault(false);
}
 

@Override
public Feature provides() {
  return Feature.named("FFEACH")
      .withOnByDefault(true)
      .withDescription("Filters mutations in compiler generated code that implements for each loops");
}
 

@Override
public Feature provides() {
    return Feature.named("FENUM")
            .withOnByDefault(true)
            .withDescription("Filters mutations in enum constructors");
}
 

@Override
public Feature provides() {
  return Feature.named("FINULL")
      .withOnByDefault(true)
      .withDescription("Filters mutations in compiler generated code that checks for null by calling getClass");
}
 

@Override
public Feature provides() {
  return Feature.named("FFBLOCK")
      .withOnByDefault(true)
      .withDescription("Filters mutations in code duplicated by finally block inlining");
}
 

@Override
public Feature provides() {
  return Feature.named("FMRNULL")
      .withOnByDefault(true)
      .withDescription("Filters mutations in compiler generated code that inserts Objects.requireNonNull for method references");
}
 

@Override
public Feature provides() {
  return Feature.named("FLOGCALL")
      .withOnByDefault(true)
      .withDescription("Filters mutations in code that makes calls to logging frameworks");
}
 

@Override
public Feature provides() {
  return Feature.named("FSTATI")
      .withOnByDefault(true)
      .withDescription("Filters mutations in static initializers and code called only from them");
}
 

@Override
public Feature provides() {
  return Feature.named("FSTATINIT")
      .withOnByDefault(true)
      .withDescription("Filters mutations in static initializers and code called only from them");
}
 

private Comparator<Feature> byName() {
  return Comparator.comparing(Feature::name);
}
 

private static Function<ProvidesFeature, Feature> toFeature() {
  return a -> a.provides();
}