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