Changes :

Fixes:
    - NPER_Writer was replacing statements with a list of statements instead of add all the statements in the list

Modifications:
    - Moved method mujava.app.Console#killStillRunningJUnitTestcaseThreads() to mujava.app.Core as static public method
    - Added a call to mujava.app.Console#killStillRunningJUnitTestcaseThreads() after each test

Additions:
    - mujava now also reports mutations score based only on compiling mutants
    - added a pushComplyType and popComplyType in mujava.op.PRVO#visit(AllocationExpression) before and after the call to unaryVisit
    - added a case for ThrowStatement in mujava.op.util.Mutator#getMutationsLeft(ParseTreeObject)

Author: saiema

src/mujava/app/Console.java

@@ -363,27 +363,10 @@ public static void main(String[] args) {
 			core.setMutationScore(ms);
 			float mutationScoreResult = core.calculateMutationScore(testClasses, classToMutate);
 			System.out.println(classToMutate + " scored : " + mutationScoreResult + " with tests : " + Arrays.asList(testClasses).toString());
-			killStillRunningJUnitTestcaseThreads();
+			Core.killStillRunningJUnitTestcaseThreads();
 		}
 	}
 
-	@SuppressWarnings("deprecation")
-	private static void killStillRunningJUnitTestcaseThreads() {
-	    Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
-	    for (Thread thread : threadSet) {
-	        if (!(thread.isDaemon())) {
-	            final StackTraceElement[] threadStackTrace = thread.getStackTrace();
-	            if (threadStackTrace.length > 1) {
-	                StackTraceElement firstMethodInvocation = threadStackTrace[threadStackTrace.length - 1];
-	                if (firstMethodInvocation.getClassName().startsWith("org.junit")) {
-	                    // HACK: must use deprecated method
-	                    thread.stop();
-	                }
-	            }
-	        }
-	    }
-	}
-	
 	private static void fullHelp() {
 		System.out.println("Mujava++");
 		System.out.println("Version : "+Core.mujavappVersion);

src/mujava/app/Core.java

@@ -11,6 +11,7 @@
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 import java.util.Map.Entry;
 
 import org.junit.runner.notification.Failure;
@@ -197,8 +198,25 @@ public float calculateMutationScore(String[] testClasses, String className) {
 				if (killed) mutantsKilled++;
 			}
 		}
-		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+'\n');
+		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');
 		return ((mutantsKilled+failedToCompile)*(float)100.0)/mutants;
 	}
+	
+	@SuppressWarnings("deprecation")
+	public static void killStillRunningJUnitTestcaseThreads() {
+	    Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
+	    for (Thread thread : threadSet) {
+	        if (!(thread.isDaemon())) {
+	            final StackTraceElement[] threadStackTrace = thread.getStackTrace();
+	            if (threadStackTrace.length > 1) {
+	                StackTraceElement firstMethodInvocation = threadStackTrace[threadStackTrace.length - 1];
+	                if (firstMethodInvocation.getClassName().startsWith("org.junit")) {
+	                    // HACK: must use deprecated method
+	                    thread.stop();
+	                }
+	            }
+	        }
+	    }
+	}
 
 }

src/mujava/app/MutationScore.java

@@ -110,6 +110,7 @@ public List<TestResult> runTestsWithMutants(List<String> testClasses, String pat
 				testToRun = MutationScore.reloader.rloadClass(test, true);
 				MuJavaJunitTestRunner mjTestRunner = new MuJavaJunitTestRunner(testToRun, MutationScore.quickDeath);
 				Result testResult = mjTestRunner.run();
+				Core.killStillRunningJUnitTestcaseThreads();
 				testResults.add(new TestResult(testResult));
 				if (!testResult.wasSuccessful() && MutationScore.quickDeath) {
 					break;

src/mujava/generations/Generate.java

@@ -20,11 +20,11 @@ public class Generate {
 	public static void main(String[] args) {
 		String clazz = "pldi" + Core.SEPARATOR + "nodecachinglinkedlist" + Core.SEPARATOR + "NodeCachingLinkedList";
 		//String[] methods = {"addFirstUglyCopy"};
-		String[] methods = {"containsBis"};
+		String[] methods = {"contains"};
 		Mutant[] ops = {	
-				Mutant.PRVOL_SMART,
-		        Mutant.PRVOR_REFINED,
-		        Mutant.PRVOU_REFINED,
+//				Mutant.PRVOL_SMART,
+//		        Mutant.PRVOR_REFINED,
+//		        Mutant.PRVOU_REFINED,
 //				Mutant.AODS,
 //				Mutant.AODU,
 //				Mutant.AOIS,
@@ -40,7 +40,7 @@ public static void main(String[] args) {
 //				Mutant.LOR,
 //				Mutant.ROR,
 //				Mutant.SOR 	
-//				Mutant.NPER
+				Mutant.NPER
 						};
 		String basePathOriginals = args[0]; //test/
 		String basePathMutants = args[1];	//mutants/

src/mujava/op/NPER.java

@@ -195,6 +195,7 @@ public void visit(ForStatement p) throws ParseTreeException {
 			ifStatements.add(whileStatement);
 			IfStatement ifStatement = createIfStatement(ifStatements, new Variable(initBoolVarDecl.getVariable()));
 			mutant.add(ifStatement);
+			mutant.setParent(p.getParent());
 			outputToFile(pCopy, mutant);
 		}
 		super.visit(p);
@@ -220,16 +221,18 @@ public void visit(WhileStatement p) throws ParseTreeException {
 			whileStatements.add(conditionTryInside);
 			WhileStatement newWhile = new WhileStatement(new Variable(condBoolVarDecl.getVariable()), whileStatements);
 			mutant.add(newWhile);
+			mutant.setParent(p.getParent());
 			outputToFile(p, mutant);
 		}
 		super.visit(p);
 	}
 
 
 	public void visit(AssignmentExpression p) throws ParseTreeException {
-		if (getMutationsLeft(p) > 0) {
+		if (getMutationsLeft(p) > 0 && p.getParent() instanceof ExpressionStatement) {
 			AssignmentExpression pCopy = (AssignmentExpression) p.makeRecursiveCopy_keepOriginalID();
 			TryStatement catchedExpressionStatement = createNullPointerExceptionTryStatement(new StatementList(new ExpressionStatement(pCopy)), new StatementList(), "NPE detected");
+			catchedExpressionStatement.setParent(p.getParent());
 			outputToFile(p, catchedExpressionStatement);
 		}
 		super.visit(p);
@@ -247,6 +250,7 @@ public void visit(ReturnStatement p) throws ParseTreeException {
 					ReturnStatement defaultReturn = new ReturnStatement(defaultValue);
 					StatementList catchStatements = new StatementList(defaultReturn);
 					TryStatement mutant = createNullPointerExceptionTryStatement(tryStatements, catchStatements, "NPE detected in return statement");
+					mutant.setParent(p.getParent());
 					outputToFile(p, mutant);
 				} catch (OJClassNotFoundException e) {
 					// TODO Auto-generated catch block
@@ -288,6 +292,7 @@ public void visit(IfStatement p) throws ParseTreeException {
 			TryStatement tryStatement = createNullPointerExceptionTryStatement(tryStatements, catchStatements, "NPE detected in condition evaluation before if statement");
 			mutant.add(tryStatement);
 			mutant.add(modifiedIfStatement);
+			mutant.setParent(p.getParent());
 			outputToFile(p, mutant);
 		}
 		super.visit(p);

src/mujava/op/NPER_Writer.java

@@ -69,7 +69,10 @@ public void visit(ForStatement o) throws ParseTreeException {
 				StatementList m = this.mutant_statements;
 				this.original_for = null;
 				this.mutant_statements = null;
-				super.visit(m);
+				for (int s = 0; s < m.size(); s++) {
+					Statement st = m.get(s);
+					super.visit(st);
+				}
 			}
 			else throw new ParseTreeException("NPER_Writer is being called with a mutant that's not a statement or a statement list");
 			// -------------------------------------------------------------
@@ -91,7 +94,10 @@ public void visit(WhileStatement o) throws ParseTreeException {
 				StatementList m = this.mutant_statements;
 				this.original_while = null;
 				this.mutant_statement = null;
-				super.visit(m);
+				for (int s = 0; s < m.size(); s++) {
+					Statement st = m.get(s);
+					super.visit(st);
+				}
 			}
 			else throw new ParseTreeException("NPER_Writer is being called with a mutant that's not a statement or a statement list");
 			// -------------------------------------------------------------
@@ -140,7 +146,10 @@ public void visit(IfStatement p) throws ParseTreeException {
 			StatementList m = this.mutant_statements;
 			this.original_if = null;
 			this.mutant_statements = null;
-			super.visit(m);
+			for (int s = 0; s < m.size(); s++) {
+				Statement st = m.get(s);
+				super.visit(st);
+			}
 			mutated_line = line_num;
 		} else {
 			super.visit(p);

src/mujava/op/PRVO.java

@@ -1889,7 +1889,9 @@ public void visit(AllocationExpression p) throws ParseTreeException {
 			return;
 		}
 		if (!this.refinedMode || getMutationsLeft(p) <= 0) return;
+		pushComplyType(p, p);
 		unaryVisit(p, p, true);
+		popComplyType(p);
 		ExpressionList args = p.getArguments();
 		for (int a = 0; a < args.size(); a++) {
 			pushAllowNull(p, compatibleAssignType(getType(args.get(a)), null));

src/mujava/op/util/Mutator.java

@@ -352,6 +352,12 @@ public static int getMutationsLeft(ParseTreeObject nl) {
 				else
 					return -1;
 			}
+			if (parent instanceof ThrowStatement) {
+				if (((ThrowStatement) parent).hasMutGenLimit())
+					return ((ThrowStatement) parent).getMutGenLimit();
+				else
+					return -1;
+			}
 			parent = parent.getParent();
 		}
 		return -1;