Changes :

Fixes:
    - repair a NumberFormatException when replacing a number literal that contains a letter at the end (e.g.: 1l) in mujava.op.PRVO.

Modifications:
    - mujava.loader.Reloader cleans up unused Reloader instances every 150 instances.
    - mujava.op.basic.LOI will only add ~ operator to unary expressions if the expression is not a statement.
    - replaced System.out.println with System.err.println when outputing errors in mujava.app.Console.
    - prints mutated file path in mujava.app.Mutator when a IOException is thrown while creating the new mutated file.

Additions:
    - added mutation.advanced.generations argument to .properties file and -g flag to Console arguments
      to set how much mutant generations to generate and if mutation score is enabled it will be calculated
      on the last generation.
    - added mutation.basic.showSurvivingMutants argument to .properties file and -W flag to Console arguments
      to show surviving mutants (those which compiled and passed all tests) at the end of the mutation score process.

Author: saiema

default.properties

@@ -10,22 +10,24 @@ path.original.bin= /home/stein/Proyects/NewMuJava/MuJava/test/
 path.tests.bin= /home/stein/Proyects/NewMuJava/MuJava/test/
 
 //where to save mutants
-path.mutants= /home/stein/mutants/
+path.mutants= /home/stein/Desktop/mutants/
 
 //class to mutate (full qualified name)
-mutation.basic.class= utils.BooleanOps
+mutation.basic.class= arithmetic.Smallest
 
 //methods to mutate (separated by spaces)
-mutation.basic.methods= and
+mutation.basic.methods= smallest
 
 //operators to use (separated by spaces)
-mutation.basic.operators= COR COI
+mutation.basic.operators= AODS AODU AOIS AOIU AORB AORS AORU ASRS COD COI COR LOD LOI LOR ROR SOR PRVOL_SMART PRVOR_REFINED PRVOU_REFINED AMC IHI EMM EOA_STRICT EOC IHD IPC ISI_SMART ISD_SMART EAM IOD IOP JDC JID JSD JSI JTD JTI_SMART OAN_RELAXED PNC OMR PPD
 
 //if mutation score will be calculated
 mutation.basic.mutationScore= true
 
 //test classes to run (fully qualified names separated by spaces)
-mutation.basic.tests= mutationScore.TestTest
+mutation.basic.tests= arithmetic.SmallestTests
+
+mutation.basic.showSurvivingMutants= true
 
 //methods that will not be used by PRVO (separated by spaces)
 mutation.advanced.bannedMethods=
@@ -43,10 +45,10 @@ mutation.advanced.allowFieldMutations= false
 mutation.advanced.allowClassMutations= false
 
 //packages that will be marked to reload (separared by spaces, empty if all are allowed)
-mutation.advanced.allowedPackagesToReload= utils mutationScore
+mutation.advanced.allowedPackagesToReload= arithmetic
 
 //allows PRVO to use numeric literal variations
-mutation.advanced.allowNumericLiteralVariations= false
+mutation.advanced.allowNumericLiteralVariations= true
 
 //stop at the first failing test for each mutant
 mutation.advanced.quickDeath= true
@@ -61,4 +63,8 @@ mutation.advanced.disablePrimitiveToObjectAssignments= false
 mutation.advanced.wrapPrimitiveToObjectAssignments= false
 
 //apply refined versions of PRVO to arguments in statements containing only a method call
-mutation.advanced.applyRefinedPRVOInMethodCallStatements= false
+mutation.advanced.applyRefinedPRVOInMethodCallStatements= true
+
+mutation.advanced.generations= 2
+
+mutation.basic.showSurvivingMutants= true

src/mujava/app/Console.java

@@ -31,6 +31,7 @@ public class Console {
 	static String[] methodsToMutate = null;
 	static boolean mutationScore = false;
 	static String[] testClasses = new String[]{"mutationScore.BooleanOpsAndTests", "mutationScore.BooleanOpsXorTests", "mutationScore.BooleanOpsXnorTests", "mutationScore.BooleanOpsOrTests"};
+	static int generations = 1;
 
 	public static void main(String[] args) {
 
@@ -67,6 +68,8 @@ public static void main(String[] args) {
 		flags.setNoValueFlag('p'); //disable mutations of the form a = b where a is of type Object and b is a primitive type expression
 		flags.setNoValueFlag('w'); //wrap mutations of the form a = b to a = new T(b), where a is of type Object and b is a primitive type expression
 		flags.setNoValueFlag('r'); //apply refined versions of PRVO to mutate arguments in statements containing only a method call
+		flags.setOptionalFlag('g'); //define how many mutants generations to generate
+		flags.setNoValueFlag('W'); //show surviving mutants
 		flags.setDependence('T', 'S');
 		flags.setDependence('S', 'T');
 		flags.setDependence('t', 'T');
@@ -82,12 +85,14 @@ public static void main(String[] args) {
 		flags.setDependence('p', 'm');
 		flags.setDependence('w', 'm');
 		flags.setDependence('r', 'm');
+		flags.setDependence('W', 'S');
 
 
 		System.out.println("Validating parameters...");
 		//================================validate input================================================//
 		if (!flags.validateInput(args)) {
-			System.out.println("To get help on how to run mujava++ please run with only flag -H");
+			System.err.println("Invalid Params");
+			System.err.println("To get help on how to run mujava++ please run with only flag -H");
 			return;
 		}
 
@@ -99,14 +104,14 @@ public static void main(String[] args) {
 		if (flags.flagExist('x')) {
 			for (String op : flags.getFlagValues('x')) {
 				if (!mi.isSupported(Mutant.valueOf(op))) {
-					System.out.println("Mutation operator ("+op+") is unsupported");
-					System.out.println("To see a list with all mutation operators currently supported run mujava++ with only flag -h");
+					System.err.println("Mutation operator ("+op+") is unsupported");
+					System.err.println("To see a list with all mutation operators currently supported run mujava++ with only flag -h");
 					return;
 				}
 				ops.add(Mutant.valueOf(op));
 			}
 		} else {
-			ops.addAll(mi.listBasicOperators());
+			ops.addAll(mi.allOps());
 		}
 		System.out.println("Operators: " + ops.toString());
 
@@ -126,7 +131,7 @@ public static void main(String[] args) {
 		//mutant source dir
 		List<String> mutDir = flags.getFlagValues('M');
 		if (mutDir.size() != 1) {
-			System.out.println("-M flag must have only one value");
+			System.err.println("-M flag must have only one value");
 			return;
 		}
 		if (verifyDirectory(mutDir.get(0))) {
@@ -140,11 +145,11 @@ public static void main(String[] args) {
 		//original source dir
 		List<String> sourceDir = flags.getFlagValues('O');
 		if (sourceDir.size() != 1) {
-			System.out.println("-O flag must have only one value");
+			System.err.println("-O flag must have only one value");
 			return;
 		}
 		if (!verifyDirectory(sourceDir.get(0))) {
-			System.out.println("Original source directory ("+sourceDir.get(0)+") doesn't exist");
+			System.err.println("Original source directory ("+sourceDir.get(0)+") doesn't exist");
 			return;
 		}
 		originalSourceDir = sourceDir.get(0);
@@ -154,11 +159,11 @@ public static void main(String[] args) {
 		//original bin dir
 		List<String> binDir = flags.getFlagValues('B');
 		if (binDir.size() != 1) {
-			System.out.println("-B flag must have only one value");
+			System.err.println("-B flag must have only one value");
 			return;
 		}
 		if (!verifyDirectory(binDir.get(0))) {
-			System.out.println("Original bin directory ("+binDir.get(0)+") doesn't exist");
+			System.err.println("Original bin directory ("+binDir.get(0)+") doesn't exist");
 			return;
 		}
 		originalBinDir = binDir.get(0);
@@ -169,11 +174,11 @@ public static void main(String[] args) {
 		if (mutationScore) {
 			List<String> testDir = flags.getFlagValues('T');
 			if (testDir.size() != 1) {
-				System.out.println("-T flag must have only one value");
+				System.err.println("-T flag must have only one value");
 				return;
 			}
 			if (!verifyDirectory(testDir.get(0))) {
-				System.out.println("Tests directory ("+testDir.get(0)+") doesn't exist");
+				System.err.println("Tests directory ("+testDir.get(0)+") doesn't exist");
 				return;
 			}
 			testBinDir = testDir.get(0);
@@ -183,7 +188,7 @@ public static void main(String[] args) {
 		//=============================verify class to mutate============================================//
 		List<String> ctm = flags.getFlagValues('m');
 		if (ctm.size() != 1) {
-			System.out.println("-m flag must have only one value");
+			System.err.println("-m flag must have only one value");
 			return;
 		}
 		System.out.println("\n\nVerifying class to mutate...");
@@ -193,7 +198,7 @@ public static void main(String[] args) {
 		System.out.println("Class to mutate as path: "+ctm.get(0).replaceAll("\\.", Core.SEPARATOR));
 		System.out.println("Class to mutate full path: "+originalSourceDir+ctm.get(0).replaceAll("\\.", Core.SEPARATOR)+".java\n");
 		if (!verifyFile(originalSourceDir+ctm.get(0).replaceAll("\\.", Core.SEPARATOR)+".java")) {
-			System.out.println("Class to mutate ("+(originalSourceDir+ctm.get(0).replaceAll("\\.", Core.SEPARATOR)+".java")+") doesn't exist");
+			System.err.println("Class to mutate ("+(originalSourceDir+ctm.get(0).replaceAll("\\.", Core.SEPARATOR)+".java")+") doesn't exist");
 			return;
 		}
 		classToMutate = ctm.get(0);
@@ -205,7 +210,7 @@ public static void main(String[] args) {
 			List<String> tclasses = flags.getFlagValues('t');
 			for (String tc : tclasses) {
 				if (!verifyFile(testBinDir+tc.replaceAll("\\.", Core.SEPARATOR)+".class")) {
-					System.out.println("Test class ("+(testBinDir+tc.replaceAll("\\.", Core.SEPARATOR)+".class")+") doesn't exist");
+					System.err.println("Test class ("+(testBinDir+tc.replaceAll("\\.", Core.SEPARATOR)+".class")+") doesn't exist");
 					return;
 				}
 			}
@@ -224,7 +229,7 @@ public static void main(String[] args) {
 			mtm.addAll(flags.getFlagValues('s'));
 			for (String m : mtm) {
 				if (!verifyMethod(m)) {
-					System.out.println("No such method ("+m+") on class to mutate ("+classToMutate+")");
+					System.err.println("No such method ("+m+") on class to mutate ("+classToMutate+")");
 					return;
 				}
 			}
@@ -350,24 +355,46 @@ public static void main(String[] args) {
 			Configuration.add(Configuration.ENABLE_REFINEMENT_IN_METHOD_CALL_STATEMENTS, Boolean.FALSE);
 		}
 
+		if (flags.flagExist('g')) {
+			List<String> valuesForGeneration = flags.getFlagValues('g');
+			if (valuesForGeneration.size() != 1) {
+				System.err.println("Only one value is accepted for flag -g (values given : " + valuesForGeneration.size() + ")");
+				return;
+			}
+			generations = Integer.valueOf(valuesForGeneration.get(0));
+			if (generations <= 0) {
+				System.err.println("Can't use a value <= 0 for generations (value used : " + generations + ")");
+				return;
+			}
+		} else {
+			generations = 1;
+		}
+		System.out.println("Generations to generate: " + generations);
+		
+		if (flags.flagExist('W')) {
+			System.out.println("Showing surviving mutants at the end of mutation score");
+			Core.showSurvivingMutants = true;
+		} else {
+			Core.showSurvivingMutants = false;
+		}
 
 
 		System.out.println("Parameters validated\n\n");
 
 		//================================Mutants generation==============================================//
 		System.out.println("Generating mutants...\n");
 		//List<Mutant> basicMutants = mi.listBasicOperators();
-		boolean result = core.generateMutants(classToMutate, methodsToMutate, ops.toArray(new Mutant[ops.size()]));
+		boolean result = core.generateMutants(classToMutate, methodsToMutate, ops.toArray(new Mutant[ops.size()]), generations);
 		if (!result) {
-			core.lastError().printStackTrace();
+			core.lastError().printStackTrace(System.err);
 		} else {
 			System.out.println(core.lastMutantsFolder().toString());
 		}
 		System.out.println("\nMutants generated\n\n");
 
 		//==============================Mutation score====================================================//;
-		if (mutationScore && !core.lastMutantsFolder().isEmpty()) {
-			System.out.println("Calculating mutation score\n");
+		if (mutationScore && core.lastMutantsFolder() != null && !core.lastMutantsFolder().isEmpty()) {
+			System.out.println("Calculating mutation score for generation (" + generations + ")\n");
 			MutationScore ms = MutationScore.newInstance(mutantsSourceDir, originalBinDir, testBinDir);
 			core.setMutationScore(ms);
 			float mutationScoreResult = core.calculateMutationScore(testClasses, classToMutate);
@@ -405,6 +432,8 @@ private static void fullHelp() {
 		System.out.println("-p								| optional parameter | effect : disable mutations of the form a = b where a is of type Object and b is a primitive type expression");
 		System.out.println("-w								| optional parameter | effect : wrap mutations of the form a = b to a = new T(b), where a is of type Object and b is a primitive type expression");
 		System.out.println("-r								| optional parameter | effect : apply refined versions of PRVO to mutate arguments in statements containing only a method call");
+		System.out.println("-g <generations>				| optional parameter | effect : generate <generations> of mutants | e.g.: -g 2 will generate the first and second generations of mutants");
+		System.out.println("-W								| optional parameter | required : -S | effect : shows which mutants that compile and were not killed by any test");
 	}
 
 	private static void mutopsHelp() {

src/mujava/app/Core.java

@@ -8,17 +8,21 @@
 import java.net.URLClassLoader;
 import java.nio.file.FileSystems;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.Map.Entry;
 
 import org.junit.runner.notification.Failure;
 
-import mujava.OpenJavaException;
 import mujava.api.Mutant;
-import mujava.api.MutantsInformationHolder;
+import mujava.generations.GenerationsGoalTester;
+import mujava.generations.GenerationsInformation;
+import mujava.generations.Generator;
+import mujava.generations.GoalTester;
+import mujava.generations.RequestGenerator;
+import mujava.generations.SameRequestGenerator;
 
 /**
  * This class execute all commands either from console or from a GUI
@@ -28,15 +32,16 @@
 public class Core {
 	public static String SEPARATOR = fixBackslash(FileSystems.getDefault().getSeparator());
 	private static Core instance = null;
-	private Mutator mutator = null;
+//	private Mutator mutator = null;
 	private static String inputDir;
 	private static String outputDir;
 	private String inputBinDir;
-	private List<MutantsInformationHolder> mutantsInformationHolder;
-	private HashMap<String, List<String>> mutantsFolders;
+	private Map<String, List<String>> mutantsFolders;
 	private Exception error;
 	private MutationScore ms;
+	private int generation = -1 ;
 	public static boolean fullVerbose = false;
+	public static boolean showSurvivingMutants = false;
 	public static final int mujavappVersion = 20151008;
 
 	public static Core newInstance(String inputDirP, String outputDirP) {
@@ -74,33 +79,28 @@ private Core(String inputDir, String outputDir) {
 	}
 
 	public boolean generateMutants(String className, String[] methods, Mutant[] mutOps) {
+		return generateMutants(className, methods, mutOps, 1);
+	}
+	
+	public boolean generateMutants(String className, String[] methods, Mutant[] mutOps, int generation) {
 		this.error = null;
 		this.mutantsFolders = null;
-		this.mutantsInformationHolder = null;
 		if (methods == null) {
-			Class<?> clazz = loadClass(className);
-			if (clazz == null) {
-				return false;
-			} else {
-				Method[] classMethods = clazz.getDeclaredMethods();
-				methods = new String[classMethods.length];
-				int i = 0;
-				for (Method m : classMethods) {
-					methods[i] = m.getName();
-					i++;
-				}
-			}
+			this.error = new IllegalArgumentException("mujava.app.Core#generateMutantsForGeneration: methods param is null");
+			return false;
 		}
-		MutationRequest mutationRequest = new MutationRequest(className.replaceAll("\\.", SEPARATOR), methods, mutOps, Core.inputDir, Core.outputDir);
-		this.mutator = new Mutator(mutationRequest);
+		String classNameAsPath = className.replaceAll("\\.", SEPARATOR);
+		MutationRequest originalRequest = new MutationRequest(classNameAsPath, methods, mutOps, Core.inputDir, Core.outputDir);
+		GoalTester goalTester = new GenerationsGoalTester(generation);
+		RequestGenerator requestGenerator = new SameRequestGenerator(originalRequest);
+		Generator.useLowMemoryMode(true);
+		Generator generator = new Generator(requestGenerator, goalTester, (Core.fullVerbose?Generator.VERBOSE_LEVEL.FULL_VERBOSE:Generator.VERBOSE_LEVEL.NO_VERBOSE));
 		try {
-			this.mutator.generateMutants();
-			this.mutantsInformationHolder = this.mutator.getMIH();
-			this.mutantsFolders = this.mutator.mutantsFolders;
-			this.mutator.resetMutantFolders();
-		} catch (ClassNotFoundException e) {
-			this.error = e;
-		} catch (OpenJavaException e) {
+			GenerationsInformation generationsInfo= generator.generate(false, true);
+			if (Core.fullVerbose) System.out.println(generationsInfo.showBasicInformation());
+			this.mutantsFolders = generator.getMutantsFolderForGeneration(generation);
+			this.generation = generation;
+		} catch (Exception e) {
 			this.error = e;
 		}
 		return this.error == null;
@@ -143,11 +143,7 @@ public Exception lastError() {
 		return this.error;
 	}
 
-	public List<MutantsInformationHolder> lastMutantInformationHolder() {
-		return this.mutantsInformationHolder;
-	}
-	
-	public HashMap<String, List<String>> lastMutantsFolder() {
+	public Map<String, List<String>> lastMutantsFolder() {
 		return this.mutantsFolders;
 	}
 
@@ -160,15 +156,18 @@ public String getOutputDir() {
 	}
 
 	public float calculateMutationScore(String[] testClasses, String className) {
+		List<String> survivingMutantsPaths = new LinkedList<>();
 		int failedToCompile = 0;
 		int mutantsKilled = 0;
 		int mutants = 0;
 		int timedOut = 0;
 		for (Entry<String, List<String>> entry : lastMutantsFolder().entrySet()) {
 			for (String path : entry.getValue()) {
 				mutants++;
-				String pathToFile = entry.getKey() + SEPARATOR + path;
-				if (!ms.compile(pathToFile + className.replaceAll("\\.", SEPARATOR)+".java")){
+				String currGen = "generation-" + this.generation;
+				String pathToFile = currGen + SEPARATOR + entry.getKey() + SEPARATOR + path;
+				String fullPathToJavaFile = pathToFile + className.replaceAll("\\.", SEPARATOR)+".java"; 
+				if (!ms.compile(fullPathToJavaFile)){
 					System.out.println("File : " + Core.outputDir + pathToFile + className.replaceAll("\\.", SEPARATOR)+".java" + " didn't compile\n");
 					failedToCompile++;
 					continue;
@@ -196,9 +195,18 @@ public float calculateMutationScore(String[] testClasses, String className) {
 					if (!killed && !r.wasSuccessful()) killed = true;
 				}
 				if (killed) mutantsKilled++;
+				if (!killed && Core.showSurvivingMutants) {
+					survivingMutantsPaths.add(fullPathToJavaFile);
+				}
 			}
 		}
 		System.out.println("Mutants : "+ mutants + " | didn't compile : " + failedToCompile + " | mutants killed by tests : "+ mutantsKilled + " | surviving mutants : " + (mutants-failedToCompile-mutantsKilled) + " | total tests that timedout : " + timedOut + " | mutation score : "+((mutantsKilled+failedToCompile)*100.0)/mutants+ " | mutation score (only compiling mutants) : " + (mutantsKilled*100.0)/(mutants-failedToCompile) + '\n');
+		if (Core.showSurvivingMutants) {
+			System.out.println("Surviving mutants paths:\n");
+			for (String sm : survivingMutantsPaths) {
+				System.out.println(sm);
+			}
+		}
 		return ((mutantsKilled+failedToCompile)*(float)100.0)/mutants;
 	}