build.xml

@@ -16,6 +16,8 @@
     </target>
 
     <target name="partitioning" depends="classes">
+      <parallel threadCount="1" timeout="5000">
+            <sequential>
               <junit printsummary="yes" fork="yes" haltonfailure="yes">
 		<classpath>
                   <pathelement path="classes/"/>
@@ -25,9 +27,13 @@
 		<formatter type="plain"/>
 		<test name="swen90006.machine.PartitioningTests"/>
               </junit>
+            </sequential>
+        </parallel>
     </target>
 
    <target name="boundary" depends="classes">
+        <parallel threadCount="1" timeout="5000">
+            <sequential>
                 <junit printsummary="yes" fork="yes" haltonfailure="yes">
         	    <classpath>
                         <pathelement path="classes/"/>
@@ -37,7 +43,8 @@
                     <formatter type="plain"/>
                     <test name="swen90006.machine.BoundaryTests"/>
                 </junit>
+            </sequential>
+        </parallel>
     </target>
 
-
 </project>

mutants/mutant-1/swen90006/machine/Machine.java

@@ -39,7 +39,7 @@ public class Machine
   /** jz ra offs       =~   if (ra == 0) pc = pc + offs else pc = pc + 1 */
   public static final String INSTRUCTION_JZ = "jz";
     
-  public static final int NUM_REGS = 32;
+  public static final int NUM_REGS = 33;
   public static final int MAX_REG = (NUM_REGS - 1);
   public static final int MEMORY_SIZE = 65536; /* 4 x as much memory as a 64 */
   public static final int MAX_ADDR = MEMORY_SIZE-1;

mutants/mutant-2/swen90006/machine/Machine.java

@@ -106,7 +106,7 @@ public class Machine
 
   private int parseReg(String s) throws InvalidInstructionException
   {
-    if (s.length() < 2){
+    if (s.length() < 3){
       throw new InvalidInstructionException();
     }
     if (s.charAt(0) != 'r'){

mutants/mutant-3/swen90006/machine/Machine.java

@@ -170,7 +170,7 @@ public class Machine
     int pc = 0;
     final int progLength = instructions.size();
     while(true){
-      if (pc < 0 || pc >= progLength){
+      if (pc < 0 && pc >= progLength){
 	/* will cause NoReturnValueException to be thrown
 	 * but that is not a bug and and indeed is what the
 	 * VM is supposed to do if the pc becomes negative,

mutants/mutant-5/swen90006/machine/Machine.java

@@ -167,7 +167,7 @@ public class Machine
   {
 
     int instructionsExecuted = 0;
-    int pc = 0;
+    int pc = 1;
     final int progLength = instructions.size();
     while(true){
       if (pc < 0 || pc >= progLength){

test/swen90006/machine/BoundaryTests.java

@@ -10,81 +10,249 @@ import java.nio.file.FileSystems;
 import org.junit.*;
 import static org.junit.Assert.*;
 
-public class BoundaryTests
-{
-  //Any method annotated with "@Before" will be executed before each test,
-  //allowing the tester to set up some shared resources.
-  @Before public void setUp()
-  {
-  }
-
-  //Any method annotated with "@After" will be executed after each test,
-  //allowing the tester to release any shared resources used in the setup.
-  @After public void tearDown()
-  {
-  }
-
-  //Any method annotation with "@Test" is executed as a test.
-  @Test public void aTest()
-  {
-    //the assertEquals method used to check whether two values are
-    //equal, using the equals method
-    final int expected = 2;
-    final int actual = 1 + 1;
-    assertEquals(expected, actual);
-  }
-
-  @Test public void anotherTest()
-  {
-    List<String> list = new ArrayList<String>();
-    list.add("a");
-    list.add("b");
-
-    //the assertTrue method is used to check whether something holds.
-    assertTrue(list.contains("a"));
-  }
-
-  //Test test opens a file and executes the machine
-  @Test public void aFileOpenTest()
-  {
-    final List<String> lines = readInstructions("examples/array.s");
-    Machine m = new Machine();
-    assertEquals(m.execute(lines), 45);
-  }
-  
-  //To test an exception, specify the expected exception after the @Test
-  @Test(expected = java.io.IOException.class) 
-    public void anExceptionTest()
-    throws Throwable
-  {
-    throw new java.io.IOException();
-  }
-
-  //This test should fail.
-  //To provide additional feedback when a test fails, an error message
-  //can be included
-  @Test public void aFailedTest()
-  {
-    //include a message for better feedback
-    final int expected = 2;
-    final int actual = 1 + 2;
-    assertEquals("Some failure message", expected, actual);
-  }
-
-  //Read in a file containing a program and convert into a list of
-  //string instructions
-  private List<String> readInstructions(String file)
-  {
-    Charset charset = Charset.forName("UTF-8");
-    List<String> lines = null;
-    try {
-      lines = Files.readAllLines(FileSystems.getDefault().getPath(file), charset);
-    }
-    catch (Exception e){
-      System.err.println("Invalid input file! (stacktrace follows)");
-      e.printStackTrace(System.err);
-      System.exit(1);
-    }
-    return lines;
+public class BoundaryTests {
+//	// Any method annotated with "@Before" will be executed before each test,
+//	// allowing the tester to set up some shared resources.
+//	@Before
+//	public void setUp() {
+//	}
+//
+//	// Any method annotated with "@After" will be executed after each test,
+//	// allowing the tester to release any shared resources used in the setup.
+//	@After
+//	public void tearDown() {
+//	}
+//
+//	// Any method annotation with "@Test" is executed as a test.
+//	@Test
+//	public void aTest() {
+//		// the assertEquals method used to check whether two values are
+//		// equal, using the equals method
+//		final int expected = 2;
+//		final int actual = 1 + 1;
+//		assertEquals(expected, actual);
+//	}
+//
+//	@Test
+//	public void anotherTest() {
+//		List<String> list = new ArrayList<String>();
+//		list.add("a");
+//		list.add("b");
+//
+//		// the assertTrue method is used to check whether something holds.
+//		assertTrue(list.contains("a"));
+//	}
+//
+//	// Test test opens a file and executes the machine
+//	@Test
+//	public void aFileOpenTest() {
+//		final List<String> lines = readInstructions("examples/array.s");
+//		Machine m = new Machine();
+//		assertEquals(m.execute(lines), 45);
+//	}
+//
+//	// To test an exception, specify the expected exception after the @Test
+//	@Test(expected = java.io.IOException.class)
+//	public void anExceptionTest() throws Throwable {
+//		throw new java.io.IOException();
+//	}
+//
+//	// This test should fail.
+//	// To provide additional feedback when a test fails, an error message
+//	// can be included
+//	@Test
+//	public void aFailedTest() {
+//		// include a message for better feedback
+//		final int expected = 2;
+//		final int actual = 1 + 2;
+//		assertEquals("Some failure message", expected, actual);
+//	}
+//
+//	// Read in a file containing a program and convert into a list of
+//	// string instructions
+//	private List<String> readInstructions(String file) {
+//		Charset charset = Charset.forName("UTF-8");
+//		List<String> lines = null;
+//		try {
+//			lines = Files.readAllLines(FileSystems.getDefault().getPath(file), charset);
+//		} catch (Exception e) {
+//			System.err.println("Invalid input file! (stacktrace follows)");
+//			e.printStackTrace(System.err);
+//			System.exit(1);
+//		}
+//		return lines;
+//	}
+
+	// Tests the off point for Register < 0
+	@Test(expected = InvalidInstructionException.class)
+	public void EC1() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("add R-1 R0");
+		machine.execute(instruction);
+	}
+
+	// Tests the off point for Register > 31
+	@Test(expected = InvalidInstructionException.class)
+	public void EC2() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("sub R32 R0");
+		machine.execute(instruction);
+	}
+
+	// Tests the off point for val < -65535
+	@Test(expected = InvalidInstructionException.class)
+	public void EC3() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("mov R0 -65536");
+		machine.execute(instruction);
+	}
+
+	// Tests the off point for val > 65535
+	@Test(expected = InvalidInstructionException.class)
+	public void EC4() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("ldr R0 R1 65536");
+		machine.execute(instruction);
+	}
+
+	// Tests the on point for Register < 0 and Last command == "RET"
+	@Test
+	public void EC5_OnPointRegisterLessThanMin() {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("ret R0");
+		assertEquals(machine.execute(instruction), 0);
+	}
+	
+	// Tests the on point for Register > 31 and Last command == "RET"
+	@Test
+	public void EC5_OnPointRegisterGreaterThanMax() {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("ret R31");
+		assertEquals(machine.execute(instruction), 0);
+	}
+
+	// Test on point for val < -65535, Register < 0 and off point for Last command == "RET"
+	@Test(expected = NoReturnValueException.class)
+	public void EC6_OnPointValLessThanMin() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("str R0 -65535 R1");
+		machine.execute(instruction);
+	}
+	
+	// Test on point for val > 65535, Register > 31 and off point for Last command == "RET"
+	@Test(expected = NoReturnValueException.class)
+	public void EC6_OnPointValGreaterThanMax() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("jz R31 65535");
+		machine.execute(instruction);
+	}
+
+	// Tests the off point for Register < 0
+	@Test(expected = InvalidInstructionException.class)
+	public void EC7() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("div R-1 R0 R1");
+		instruction.add("ret R0");
+		machine.execute(instruction);
+	}
+
+	// Tests the off point for Register > 31
+	@Test(expected = InvalidInstructionException.class)
+	public void EC8() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("jmp 1");
+		instruction.add("ret R32");
+		machine.execute(instruction);
+	}
+
+	// Test off point for val < -65535
+	@Test(expected = InvalidInstructionException.class)
+	public void EC9() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("jz R0 -65536");
+		instruction.add("ret R0");
+		machine.execute(instruction);
+	}
+
+	// Test off point for val > 65535
+	@Test(expected = InvalidInstructionException.class)
+	public void EC10() throws Throwable {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("mov R0 65536");
+		instruction.add("jz R0 1");
+		instruction.add("ret R0");
+		machine.execute(instruction);
+	}
+
+	// Test on points for Register < 0, Register > 31, val < -65535, val > 65535 and Last command == "RET" 
+	@Test
+	public void EC11() {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("mov R0 -65535");
+		instruction.add("mov R31 65535");
+		instruction.add("MUL R1 R0 R31");
+		instruction.add("ret R31");
+		assertEquals(machine.execute(instruction), 65535);
+	}
+
+	// Test on point for Register < 0, Register > 31, val < -65535, val > 65535 and off point for Last command == "RET"
+	@Test(expected = NoReturnValueException.class)
+	public void EC12() {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("mov R0 -65535");
+		instruction.add("mov R31 65535");
+		instruction.add("jmp -5");
+		machine.execute(instruction);
+	}
+
+	// Test on point for wrong syntax
+	@Test(expected = InvalidInstructionException.class)
+	public void EC13_On() {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("");
+		instruction.add("abc");
+		machine.execute(instruction);
+	}
+	
+	// Test off point for wrong syntax
+	@Test
+	public void EC13_Off() {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("ret R0");
+		machine.execute(instruction);
+		assertEquals(machine.execute(instruction), 0);
+	}
+	
+	// Test on point for list length == 0
+	@Test(expected = NoReturnValueException.class)
+	public void EC14_On() {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		machine.execute(instruction);
+	}
+	
+	// Test off point for list length == 0
+	@Test(expected = InvalidInstructionException.class)
+	public void EC14_Off() {
+		Machine machine = new Machine();
+		List<String> instruction = new ArrayList<>();
+		instruction.add("ABC AA");
+		machine.execute(instruction);
 	}
 }

test/swen90006/machine/PartitioningTests.java

@@ -8,83 +8,132 @@ import java.nio.file.Files;
 import java.nio.file.FileSystems;
 
 import org.junit.*;
+
+import com.sun.xml.internal.ws.util.StringUtils;
+
 import static org.junit.Assert.*;
 
-public class PartitioningTests
-{
-  //Any method annotated with "@Before" will be executed before each test,
-  //allowing the tester to set up some shared resources.
-  @Before public void setUp()
-  {
+public class PartitioningTests {
+
+		@Test(expected = InvalidInstructionException.class)
+		public void EC1() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("add R-1 R0");
+			machine.execute(instruction);
+		}
+
+		@Test(expected = InvalidInstructionException.class)
+		public void EC2() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("sub R32 R0");
+			machine.execute(instruction);
+		}
+
+		@Test(expected = InvalidInstructionException.class)
+		public void EC3() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("mov R0 -65536");
+			machine.execute(instruction);
+		}
+
+		@Test(expected = InvalidInstructionException.class)
+		public void EC4() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("ldr R0 R1 65536");
+			machine.execute(instruction);
 		}
 
-  //Any method annotated with "@After" will be executed after each test,
-  //allowing the tester to release any shared resources used in the setup.
-  @After public void tearDown()
-  {
+		@Test
+		public void EC5() {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("ret R0");
+			assertEquals(machine.execute(instruction), 0);
 		}
 
-  //Any method annotation with "@Test" is executed as a test.
-  @Test public void aTest()
-  {
-    //the assertEquals method used to check whether two values are
-    //equal, using the equals method
-    final int expected = 2;
-    final int actual = 1 + 1;
-    assertEquals(expected, actual);
+		@Test(expected = NoReturnValueException.class)
+		public void EC6() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("jmp -1");
+			machine.execute(instruction);
 		}
 		
-  @Test public void anotherTest()
-  {
-    List<String> list = new ArrayList<String>();
-    list.add("a");
-    list.add("b");
+		@Test(expected = InvalidInstructionException.class)
+		public void EC7() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("div R-1 R0 R1");
+			instruction.add("ret R0");
+			machine.execute(instruction);
+		}
 
-    //the assertTrue method is used to check whether something holds.
-    assertTrue(list.contains("a"));
+		@Test(expected = InvalidInstructionException.class)
+		public void EC8() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("str R32 1 R0");
+			instruction.add("ret R0");
+			machine.execute(instruction);
 		}
 
-  //Test test opens a file and executes the machine
-  @Test public void aFileOpenTest()
-  {
-    final List<String> lines = readInstructions("examples/array.s");
-    Machine m = new Machine();
-    assertEquals(m.execute(lines), 45);
+		@Test(expected = InvalidInstructionException.class)
+		public void EC9() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("jz R0 -65536");
+			instruction.add("ret R0");
+			machine.execute(instruction);
 		}
 
-  //To test an exception, specify the expected exception after the @Test
-  @Test(expected = java.io.IOException.class) 
-    public void anExceptionTest()
-    throws Throwable
-  {
-    throw new java.io.IOException();
+		@Test(expected = InvalidInstructionException.class)
+		public void EC10() throws Throwable {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("mov R0 65536");
+			instruction.add("jz R0 1");
+			instruction.add("ret R0");
+			machine.execute(instruction);
 		}
  
-  //This test should fail.
-  //To provide additional feedback when a test fails, an error message
-  //can be included
-  @Test public void aFailedTest()
-  {
-    //include a message for better feedback
-    final int expected = 2;
-    final int actual = 1 + 2;
-    assertEquals("Some failure message", expected, actual);
+		@Test
+		public void EC11() {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("mov R0 -65535");
+			instruction.add("mov R31 65535");
+			instruction.add("mul R1 R0 R31");
+			instruction.add("ret R0");
+			assertEquals(machine.execute(instruction), -65535);
 		}
 
-  //Read in a file containing a program and convert into a list of
-  //string instructions
-  private List<String> readInstructions(String file)
-  {
-    Charset charset = Charset.forName("UTF-8");
-    List<String> lines = null;
-    try {
-      lines = Files.readAllLines(FileSystems.getDefault().getPath(file), charset);
+		@Test(expected = NoReturnValueException.class)
+		public void EC12() {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("mov R0 -65535");
+			instruction.add("mov R31 65535");
+			instruction.add("jmp 2");
+			machine.execute(instruction);
 		}
-    catch (Exception e){
-      System.err.println("Invalid input file! (stacktrace follows)");
-      e.printStackTrace(System.err);
-      System.exit(1);
+
+		@Test(expected = InvalidInstructionException.class)
+		public void EC13() {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			instruction.add("");
+			instruction.add("abc");
+			machine.execute(instruction);
 		}
-    return lines;
+		
+		@Test(expected = NoReturnValueException.class)
+		public void EC14() {
+			Machine machine = new Machine();
+			List<String> instruction = new ArrayList<>();
+			machine.execute(instruction);
 		}
 }