allow plugable mutation groupers

Author: hcoles

pitest-entry/src/main/java/org/pitest/mutationtest/build/DefaultMutationGrouperFactory.java

@@ -3,6 +3,7 @@
 import java.util.Properties;
 
 import org.pitest.classpath.CodeSource;
+import org.pitest.plugin.Feature;
 
 public class DefaultMutationGrouperFactory implements MutationGrouperFactory {
 
@@ -17,4 +18,11 @@ public MutationGrouper makeFactory(final Properties props,
     return new DefaultGrouper(unitSize);
   }
 
+  @Override
+  public Feature provides() {
+    return Feature.named("defaultgrouper")
+            .asInternalFeature()
+            .withOnByDefault(true)
+            .withDescription(description());
+  }
 }

pitest-entry/src/main/java/org/pitest/mutationtest/build/MutationGrouperFactory.java

@@ -3,9 +3,15 @@
 import java.util.Properties;
 
 import org.pitest.classpath.CodeSource;
+import org.pitest.plugin.ProvidesFeature;
 import org.pitest.plugin.ToolClasspathPlugin;
 
-public interface MutationGrouperFactory extends ToolClasspathPlugin {
+/**
+ * Groups mutations within units. Additional precautions must be taken to ensure
+ * JVMS do not become poisoned if mutations from different classes are grouped within
+ * the same unit. Do not implement unless you understand this and know what you are doing.
+ */
+public interface MutationGrouperFactory extends ToolClasspathPlugin, ProvidesFeature {
 
   MutationGrouper makeFactory(Properties props, CodeSource codeSource,
       int numberOfThreads, int unitSize);

pitest-entry/src/main/java/org/pitest/mutationtest/config/PluginServices.java

@@ -95,7 +95,7 @@ Collection<? extends TestPluginFactory> findTestFrameworkPlugins() {
     return load(TestPluginFactory.class);
   }
 
-  Collection<? extends MutationGrouperFactory> findGroupers() {
+  Collection<MutationGrouperFactory> findGroupers() {
     return load(MutationGrouperFactory.class);
   }
 

pitest-entry/src/main/java/org/pitest/mutationtest/config/SettingsFactory.java

@@ -117,11 +117,24 @@ public JavaExecutableLocator getJavaExecutable() {
   }
 
   public MutationGrouperFactory getMutationGrouper() {
-    // Grouping behaviour is important. We cannot have more than 1 class mutated within
-    // a JVM or else the last mutation will poison the next. This restriction can only
-    // be removed if the hotswap functionality is reworked.
-    // Grouping behaviour is therefore hard coded for now.
-    return new DefaultMutationGrouperFactory();
+    // Grouping behaviour is important. Without additional work to ensure a JVM is
+    // not poisoned, grouping mutations from different classes together will result
+    // in incorrect results. Implement with care.
+    final FeatureParser parser = new FeatureParser();
+    Collection<MutationGrouperFactory> available = this.plugins.findGroupers();
+    FeatureSelector<MutationGrouperFactory> features = new FeatureSelector<>(parser.parseFeatures(this.options.getFeatures()), available);
+    List<MutationGrouperFactory> enabled = features.getActiveFeatures();
+
+    if (enabled.isEmpty()) {
+      return new DefaultMutationGrouperFactory();
+    }
+
+    if (enabled.size() > 1) {
+      throw new RuntimeException("Only one grouper may be enabled");
+    }
+
+    return enabled.get(0);
+
   }
 
   public CodeSource createCodeSource(ProjectClassPaths classPath) {