From 19637825c13a5f44fdb159a13a0d7fa269559811 Mon Sep 17 00:00:00 2001
From: Wei ZHOU <w.zhou19@student.unimelb.edu.au>
Date: Mon, 3 Sep 2018 13:17:22 +1000
Subject: [PATCH] a1

---
 .../mutant-1/swen90006/machine/Machine.java   |   2 +-
 .../mutant-2/swen90006/machine/Machine.java   |   2 +-
 .../mutant-3/swen90006/machine/Machine.java   |   2 +-
 .../mutant-4/swen90006/machine/Machine.java   |   2 +-
 .../mutant-5/swen90006/machine/Machine.java   |   2 +-
 test/swen90006/machine/BoundaryTests.java     | 333 +++++++++++++++++-
 test/swen90006/machine/PartitioningTests.java | 307 ++++++++++++++++
 7 files changed, 644 insertions(+), 6 deletions(-)

diff --git a/mutants/mutant-1/swen90006/machine/Machine.java b/mutants/mutant-1/swen90006/machine/Machine.java
index 9bf5731..7bff094 100644
--- a/mutants/mutant-1/swen90006/machine/Machine.java
+++ b/mutants/mutant-1/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() > 2){
       throw new InvalidInstructionException();
     }
     if (s.charAt(0) != 'r'){
diff --git a/mutants/mutant-2/swen90006/machine/Machine.java b/mutants/mutant-2/swen90006/machine/Machine.java
index 9bf5731..e5dd51a 100644
--- a/mutants/mutant-2/swen90006/machine/Machine.java
+++ b/mutants/mutant-2/swen90006/machine/Machine.java
@@ -73,7 +73,7 @@ public class Machine
     
   private void do_div(int dest, int src1, int src2)
   {
-    if (regs[src2] == 0){
+    if (regs[src2] != 0){
       /* no op */
     }else{
       regs[dest] = regs[src1] / regs[src2];
diff --git a/mutants/mutant-3/swen90006/machine/Machine.java b/mutants/mutant-3/swen90006/machine/Machine.java
index 9bf5731..f393b91 100644
--- a/mutants/mutant-3/swen90006/machine/Machine.java
+++ b/mutants/mutant-3/swen90006/machine/Machine.java
@@ -96,7 +96,7 @@ public class Machine
     }else if(regs[a] + offs < 0){
       /* no op */
     }else{
-      memory[regs[a] + offs] = regs[b];
+      memory[regs[a] - offs] = regs[b];
     }
   }
 
diff --git a/mutants/mutant-4/swen90006/machine/Machine.java b/mutants/mutant-4/swen90006/machine/Machine.java
index 9bf5731..f83c1d0 100644
--- a/mutants/mutant-4/swen90006/machine/Machine.java
+++ b/mutants/mutant-4/swen90006/machine/Machine.java
@@ -270,7 +270,7 @@ public class Machine
 	count++;
 	continue; /* avoid default increment of pc below */
       } else if (toks[0].equals(INSTRUCTION_JZ)){
-	if (toks.length != 3){
+	if (toks.length == 3){
 	  throw new InvalidInstructionException();
 	}
 	int ra = parseReg(toks[1]);
diff --git a/mutants/mutant-5/swen90006/machine/Machine.java b/mutants/mutant-5/swen90006/machine/Machine.java
index 9bf5731..527f841 100644
--- a/mutants/mutant-5/swen90006/machine/Machine.java
+++ b/mutants/mutant-5/swen90006/machine/Machine.java
@@ -262,7 +262,7 @@ public class Machine
 	int offs = parseOffset(toks[2]);
 	do_move(rd,offs);
       } else if (toks[0].equals(INSTRUCTION_JUMP)){
-	if (toks.length != 2){
+	if (toks.length == 2){
 	  throw new InvalidInstructionException();
 	}
 	int offs = parseOffset(toks[1]);
diff --git a/test/swen90006/machine/BoundaryTests.java b/test/swen90006/machine/BoundaryTests.java
index 61ce1ca..3a032f2 100644
--- a/test/swen90006/machine/BoundaryTests.java
+++ b/test/swen90006/machine/BoundaryTests.java
@@ -24,6 +24,7 @@ public class BoundaryTests
   {
   }
 
+/*
   //Any method annotation with "@Test" is executed as a test.
   @Test public void aTest()
   {
@@ -70,7 +71,8 @@ public class BoundaryTests
     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)
@@ -87,4 +89,333 @@ public class BoundaryTests
     }
     return lines;
   }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void num1_Test(){
+	  Machine m = new Machine();
+	  List<String> num1 = new ArrayList<String>();
+	  num1.add("ADD R32 R0 R1");
+	  num1.add("RET R0");
+
+	  m.execute(num1);
+  }
+  
+  @Test
+  public void num2_Test(){
+	  Machine m = new Machine();
+	  List<String> num2 = new ArrayList<String>();
+	  num2.add("ADD R0 R1 R2");
+	  num2.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(num2), actual);
+  }
+  
+  @Test
+  public void num3_Test(){
+	  Machine m = new Machine();
+	  List<String> num3 = new ArrayList<String>();
+	  num3.add("MOV R0 1");
+	  num3.add("DIV R0 R1 R2");
+	  num3.add("RET R0");
+	  final int actual = 1;
+	  assertEquals(m.execute(num3), actual);
+  }
+  
+  @Test
+  public void num4_Test(){
+	  Machine m = new Machine();
+	  List<String> num4 = new ArrayList<String>();
+	  num4.add("MOV R0 3");
+	  num4.add("MOV R1 -1");
+	  num4.add("DIV R2 R0 R1");
+	  num4.add("RET R2");
+	  final int actual = -3;
+	  assertEquals(m.execute(num4), actual);
+  }
+  
+  @Test
+  public void num5_Test(){
+	  Machine m = new Machine();
+	  List<String> num5 = new ArrayList<String>();
+	  num5.add("MOV R0 3");
+	  num5.add("MOV R1 1");
+	  num5.add("DIV R2 R0 R1");
+	  num5.add("RET R2");
+	  final int actual = 3;
+	  assertEquals(m.execute(num5), actual);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void num6_Test(){
+	  Machine m = new Machine();
+	  List<String> num6 = new ArrayList<String>();
+	  num6.add("MOV R1 1");
+	  num6.add("DIV R32 R0 R1");
+	  num6.add("RET R0");
+
+	  m.execute(num6);
+  }
+  
+  @Test
+  public void num7_Test(){
+	  Machine m = new Machine();
+	  List<String> num7 = new ArrayList<String>();
+	  num7.add("MOV R2 2");
+	  num7.add("MOV R3 2");
+	  num7.add("DIV R0 R3 R2");
+	  num7.add("RET R0");
+	  final int actual = 1;
+	  assertEquals(m.execute(num7), actual);
+  }
+  
+  @Test
+  public void num8_Test(){
+	  Machine m = new Machine();
+	  List<String> num8 = new ArrayList<String>();
+	  num8.add("LDR R0 R1 0");
+	  num8.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(num8), actual);
+  }
+  
+  @Test
+  public void num9_Test(){
+	  Machine m = new Machine();
+	  List<String> num9 = new ArrayList<String>();
+	  num9.add("LDR R0 R1 65535");
+	  num9.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(num9), actual);
+  }
+  
+  @Test
+  public void num10_Test(){
+	  Machine m = new Machine();
+	  List<String> num10 = new ArrayList<String>();
+	  num10.add("MOV R0 1");
+	  num10.add("LDR R0 R1 -1");
+	  num10.add("RET R0");
+	  final int actual = 1;
+	  assertEquals(m.execute(num10), actual);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void num11_Test(){
+	  Machine m = new Machine();
+	  List<String> num11 = new ArrayList<String>();
+	  num11.add("LDR R0 R1 65536");
+	  num11.add("RET R0");
+	  m.execute(num11);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void num12_Test(){
+	  Machine m = new Machine();
+	  List<String> num12 = new ArrayList<String>();
+	  num12.add("LDR R2 R32 0");
+	  num12.add("RET R2");
+	  m.execute(num12);
+  }
+  
+  @Test
+  public void num13_Test(){
+	  Machine m = new Machine();
+	  List<String> num13 = new ArrayList<String>();
+	  num13.add("LDR R0 R2 0");
+	  num13.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(num13), actual);
+  }
+  
+  @Test
+  public void num14_Test(){
+	  Machine m = new Machine();
+	  List<String> num14 = new ArrayList<String>();
+	  num14.add("MOV R0 1");
+	  num14.add("JZ R0 1");
+	  num14.add("MOV R2 2");
+	  num14.add("RET R2");
+	  final int actual = 2;
+	  assertEquals(m.execute(num14), actual);
+  }
+  
+  @Test(timeout = 5000)
+  public void num15_Test(){
+	  Machine m = new Machine();
+	  List<String> num15 = new ArrayList<String>();
+	  num15.add("JZ R0 0");
+	  num15.add("RET R2");
+	  m.execute(num15);
+  }
+  
+  @Test(expected = NoReturnValueException.class)
+  public void num16_Test(){
+	  Machine m = new Machine();
+	  List<String> num16 = new ArrayList<String>();
+	  num16.add("JZ R0 -1");
+	  num16.add("RET R0");
+	  m.execute(num16);
+  }
+  
+  @Test(expected = NoReturnValueException.class)
+  public void num17_Test(){
+	  Machine m = new Machine();
+	  List<String> num17 = new ArrayList<String>();
+	  num17.add("JZ R0 2");
+	  num17.add("RET R0");
+	  m.execute(num17);
+  }
+  
+  @Test
+  public void num18_Test(){
+	  Machine m = new Machine();
+	  List<String> num18 = new ArrayList<String>();
+	  num18.add("JZ R0 3");
+	  num18.add("MOV R1 2");
+	  num18.add("MOV R2 2");
+	  num18.add("RET R1");
+	  final int actual = 0;
+	  assertEquals(m.execute(num18), actual);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void num19_Test(){
+	  Machine m = new Machine();
+	  List<String> num19 = new ArrayList<String>();
+	  num19.add("RET R32");
+	  m.execute(num19);
+  }
+  
+  @Test
+  public void num20_Test(){
+	  Machine m = new Machine();
+	  List<String> num20 = new ArrayList<String>();
+	  num20.add("RET R31");
+	  final int actual = 0;
+	  assertEquals(m.execute(num20), actual);
+  }
+  
+  @Test(timeout = 5000)
+  public void num21_Test(){
+	  Machine m = new Machine();
+	  List<String> num21 = new ArrayList<String>();
+	  num21.add("JMP 0");
+	  m.execute(num21);
+  }
+  
+  @Test(expected = NoReturnValueException.class)
+  public void num22_Test(){
+	  Machine m = new Machine();
+	  List<String> num22 = new ArrayList<String>();
+	  num22.add("JMP -1");
+	  num22.add("RET R0");
+	  m.execute(num22);
+  }
+  
+  @Test(expected = NoReturnValueException.class)
+  public void num23_Test(){
+	  Machine m = new Machine();
+	  List<String> num23 = new ArrayList<String>();
+	  num23.add("JMP 2");
+	  num23.add("RET R0");
+	  m.execute(num23);
+  }
+  
+  @Test
+  public void num24_Test(){
+	  Machine m = new Machine();
+	  List<String> num24 = new ArrayList<String>();
+	  num24.add("JMP 1");
+	  num24.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(num24), actual);
+  }
+  
+  @Test
+  public void num25_Test(){
+	  Machine m = new Machine();
+	  List<String> num25 = new ArrayList<String>();
+	  num25.add("MOV R0 -65535");
+	  num25.add("RET R0");
+	  final int actual = -65535;
+	  assertEquals(m.execute(num25), actual);
+  }
+  
+  @Test
+  public void num26_Test(){
+	  Machine m = new Machine();
+	  List<String> num26 = new ArrayList<String>();
+	  num26.add("MOV R0 65535");
+	  num26.add("RET R0");
+	  final int actual = 65535;
+	  assertEquals(m.execute(num26), actual);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void num27_Test(){
+	  Machine m = new Machine();
+	  List<String> num27 = new ArrayList<String>();
+	  num27.add("MOV R0 -65536");
+	  num27.add("RET R0");
+	  m.execute(num27);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void num28_Test(){
+	  Machine m = new Machine();
+	  List<String> num28 = new ArrayList<String>();
+	  num28.add("MOV R0 65536");
+	  num28.add("RET R0");
+	  m.execute(num28);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void num29_Test(){
+	  Machine m = new Machine();
+	  List<String> num29 = new ArrayList<String>();
+	  num29.add("MOV R32 2");
+	  num29.add("RET R0");
+	  m.execute(num29);
+  }
+  
+  @Test
+  public void num30_Test(){
+	  Machine m = new Machine();
+	  List<String> num30 = new ArrayList<String>();
+	  num30.add("MOV R31 2");
+	  num30.add("RET R31");
+	  final int actual = 2;
+	  assertEquals(m.execute(num30), actual);
+  }
+  
+  @Test
+  public void num31_Test(){
+	  Machine m = new Machine();
+	  List<String> num31 = new ArrayList<String>();
+	  num31.add("STR R1 0 R0");
+	  num31.add("RET R1");
+	  final int actual = 0;
+	  assertEquals(m.execute(num31), actual);
+  }
+  
+  @Test
+  public void num32_Test(){
+	  Machine m = new Machine();
+	  List<String> num32 = new ArrayList<String>();
+	  num32.add("STR R0 65535 R1");
+	  num32.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(num32), actual);
+  }
+  
+  @Test
+  public void num33_Test(){
+	  Machine m = new Machine();
+	  List<String> num33 = new ArrayList<String>();
+	  num33.add("STR R0 -65535 R1");
+	  num33.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(num33), actual);
+  }
+  
 }
diff --git a/test/swen90006/machine/PartitioningTests.java b/test/swen90006/machine/PartitioningTests.java
index 5494b44..85eb421 100644
--- a/test/swen90006/machine/PartitioningTests.java
+++ b/test/swen90006/machine/PartitioningTests.java
@@ -24,6 +24,7 @@ public class PartitioningTests
   {
   }
 
+/* 
   //Any method annotation with "@Test" is executed as a test.
   @Test public void aTest()
   {
@@ -70,6 +71,7 @@ public class PartitioningTests
     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
@@ -87,4 +89,309 @@ public class PartitioningTests
     }
     return lines;
   }
+  
+  @Test(expected = InvalidInstructionException.class) 
+  public void EC1_Test(){
+	  Machine m = new Machine();
+	  List<String> EC1 = new ArrayList<String>();
+	  EC1.add("WRONG INPUT");
+	  EC1.add("RET R0");
+	  m.execute(EC1);
+  }
+  
+  @Test
+  public void EC3_Test(){
+	  Machine m = new Machine();
+	  List<String> EC3 = new ArrayList<String>();
+	  EC3.add(";; This is comment! ");
+	  EC3.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(EC3), actual);
+  }
+  
+  @Test(expected = InvalidInstructionException.class) 
+  public void EC12_Test(){
+	  Machine m = new Machine();
+	  List<String> EC12 = new ArrayList<String>();
+	  EC12.add("ADD R32 R0 R1; Comment ");
+	  EC12.add("RET R0");
+	  m.execute(EC12);
+  }
+  
+  @Test
+  public void EC13_Test(){
+	  Machine m = new Machine();
+	  List<String> EC13 = new ArrayList<String>();
+	  EC13.add("MOV R1 1");
+	  EC13.add("ADD R0 R1 R2");
+	  EC13.add("RET R0");
+	  final int actual = 1;
+	  assertEquals(m.execute(EC13), actual);
+  }
+  
+  @Test
+  public void EC14_Test(){
+	  Machine m = new Machine();
+	  List<String> EC14 = new ArrayList<String>();
+	  EC14.add("MOV R0 1");
+	  EC14.add("DIV R0 R1 R2");
+	  EC14.add("RET R0");
+	  final int actual = 1;
+	  assertEquals(m.execute(EC14), actual);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC31_Test(){
+	  Machine m = new Machine();
+	  List<String> EC31 = new ArrayList<String>();
+	  EC31.add("MOV R0 1");
+	  EC31.add("MOV R1 1");
+	  EC31.add("DIV R32 R1 R0");
+	  EC31.add("RET R1");
+	  m.execute(EC31);
+  }
+  
+  @Test
+  public void EC32_Test(){
+	  Machine m = new Machine();
+	  List<String> EC32 = new ArrayList<String>();
+	  EC32.add("MOV R0 2");
+	  EC32.add("MOV R1 4");
+	  EC32.add("DIV R2 R1 R0");
+	  EC32.add("RET R2");
+	  final int actual = 2;
+	  assertEquals(m.execute(EC32), actual);
+  }
+  
+  @Test
+  public void EC16_Test(){
+	  Machine m = new Machine();
+	  List<String> EC16 = new ArrayList<String>();
+	  EC16.add("LDR R0 R1 -1");
+	  EC16.add("RET R0");
+	  final int actual = 0;
+	  assertEquals(m.execute(EC16), actual);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC18_Test(){
+	  Machine m = new Machine();
+	  List<String> EC18 = new ArrayList<String>();
+	  EC18.add("LDR R0 R1 65536");
+	  EC18.add("RET R0");
+	  m.execute(EC18);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC33_Test(){
+	  Machine m = new Machine();
+	  List<String> EC33 = new ArrayList<String>();
+	  EC33.add("MOV R0 10");
+	  EC33.add("STR R1 0 R0");
+	  EC33.add("LDR R2 R32 0");
+	  EC33.add("RET R2");
+	  m.execute(EC33);
+  }
+  
+  @Test
+  public void EC34_Test(){
+	  Machine m = new Machine();
+	  List<String> EC34 = new ArrayList<String>();
+	  EC34.add("MOV R0 10");
+	  EC34.add("STR R1 0 R0");
+	  EC34.add("LDR R2 R3 0");
+	  EC34.add("RET R2");
+	  final int actual = 10;
+	  assertEquals(m.execute(EC34), actual);
+  }
+  
+  @Test
+  public void EC20_Test(){
+	  Machine m = new Machine();
+	  List<String> EC20 = new ArrayList<String>();
+	  EC20.add("MOV R0 1");
+	  EC20.add("JZ R0 1");
+	  EC20.add("MOV R2 2");
+	  EC20.add("RET R2");
+	  final int actual = 2;
+	  assertEquals(m.execute(EC20), actual);
+  }
+  
+  @Test(timeout = 5000)
+  public void EC36_Test(){
+	  Machine m = new Machine();
+	  List<String> EC36 = new ArrayList<String>();
+	  EC36.add("JZ R0 0");
+	  EC36.add("RET R0");
+	  m.execute(EC36);
+  }
+  
+  @Test(expected = NoReturnValueException.class)
+  public void EC44_Test(){
+	  Machine m = new Machine();
+	  List<String> EC44 = new ArrayList<String>();
+	  EC44.add("JZ R0 -10");
+	  EC44.add("RET R0");
+	  m.execute(EC44);
+  }
+  
+  @Test
+  public void EC45_Test(){
+	  Machine m = new Machine();
+	  List<String> EC45 = new ArrayList<String>();
+	  EC45.add("JZ R0 2");
+	  EC45.add("MOV R1 2");
+	  EC45.add("MOV R2 2");
+	  EC45.add("RET R1");
+	  final int actual = 0;
+	  assertEquals(m.execute(EC45), actual);
+  }
+  
+  @Test(expected = NoReturnValueException.class)
+  public void EC46_Test(){
+	  Machine m = new Machine();
+	  List<String> EC46 = new ArrayList<String>();
+	  EC46.add("JZ R0 10");
+	  EC46.add("RET R0");
+	  m.execute(EC46);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC21_Test(){
+	  Machine m = new Machine();
+	  List<String> EC21 = new ArrayList<String>();
+	  EC21.add("RET R32");
+	  EC21.add("RET R0");
+	  m.execute(EC21);
+  }
+  
+  @Test
+  public void EC22_Test(){
+	  Machine m = new Machine();
+	  List<String> EC22 = new ArrayList<String>();
+	  EC22.add("RET R2");
+	  final int actual = 0;
+	  assertEquals(m.execute(EC22), actual);
+  }
+  
+  @Test(timeout = 5000)
+  public void EC24_Test(){
+	  Machine m = new Machine();
+	  List<String> EC24 = new ArrayList<String>();
+	  EC24.add("JMP 0");
+	  m.execute(EC24);
+  }
+  
+  @Test(expected = NoReturnValueException.class)
+  public void EC37_Test(){
+	  Machine m = new Machine();
+	  List<String> EC37 = new ArrayList<String>();
+	  EC37.add("JMP -10");
+	  EC37.add("RET R0");
+	  m.execute(EC37);
+  }
+  
+  @Test
+  public void EC38_Test(){
+	  Machine m = new Machine();
+	  List<String> EC38 = new ArrayList<String>();
+	  EC38.add("JMP 2");
+	  EC38.add("MOV R1 2");
+	  EC38.add("MOV R2 2");
+	  EC38.add("RET R1");
+	  final int actual = 0;
+	  assertEquals(m.execute(EC38), actual);
+  }
+  
+  @Test(expected = NoReturnValueException.class)
+  public void EC39_Test(){
+	  Machine m = new Machine();
+	  List<String> EC39 = new ArrayList<String>();
+	  EC39.add("JMP 10");
+	  EC39.add("RET R0");
+	  m.execute(EC39);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC25_Test(){
+	  Machine m = new Machine();
+	  List<String> EC25 = new ArrayList<String>();
+	  EC25.add("MOV R0 -65537");
+	  EC25.add("RET R0");
+	  m.execute(EC25);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC27_Test(){
+	  Machine m = new Machine();
+	  List<String> EC27 = new ArrayList<String>();
+	  EC27.add("MOV R0 65536");
+	  EC27.add("RET R0");
+	  m.execute(EC27);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC40_Test(){
+	  Machine m = new Machine();
+	  List<String> EC40 = new ArrayList<String>();
+	  EC40.add("MOV R32 1");
+	  EC40.add("RET R0");
+	  m.execute(EC40);
+  }
+  
+  @Test
+  public void EC41_Test(){
+	  Machine m = new Machine();
+	  List<String> EC41 = new ArrayList<String>();
+	  EC41.add("MOV R0 1");
+	  EC41.add("RET R0");
+	  final int actual = 1;
+	  assertEquals(m.execute(EC41), actual);
+  }
+  
+  @Test
+  public void EC28_Test(){
+	  Machine m = new Machine();
+	  List<String> EC28 = new ArrayList<String>();
+	  EC28.add("MOV R1 1");
+	  EC28.add("STR R0 -1 R1");
+	  EC28.add("LDR R2 R3 0");
+	  EC28.add("RET R2");
+	  final int actual = 0;
+	  assertEquals(m.execute(EC28), actual);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC30_Test(){
+	  Machine m = new Machine();
+	  List<String> EC30 = new ArrayList<String>();
+	  EC30.add("MOV R1 1");
+	  EC30.add("STR R0 65536 R1");
+	  EC30.add("LDR R2 R3 0");
+	  EC30.add("RET R2");
+	  m.execute(EC30);
+  }
+  
+  @Test(expected = InvalidInstructionException.class)
+  public void EC42_Test(){
+	  Machine m = new Machine();
+	  List<String> EC42 = new ArrayList<String>();
+	  EC42.add("MOV R1 1");
+	  EC42.add("STR R32 10 R1");
+	  EC42.add("LDR R2 R3 0");
+	  EC42.add("RET R2");
+	  m.execute(EC42);
+  }
+  
+  @Test
+  public void EC43_Test(){
+	  Machine m = new Machine();
+	  List<String> EC43 = new ArrayList<String>();
+	  EC43.add("MOV R1 10");
+	  EC43.add("STR R0 0 R1");
+	  EC43.add("LDR R2 R3 0");
+	  EC43.add("RET R2");
+	  final int actual = 10;
+	  assertEquals(m.execute(EC43), actual);
+  }
 }
-- 
GitLab