From 547bfd818e2a71d4887703b489d8e04aafeaad0f Mon Sep 17 00:00:00 2001 From: Abdul Mateen Ahmad Khan <a.khan21@student.unimelb.edu.au> Date: Sun, 2 Sep 2018 15:24:58 +1000 Subject: [PATCH] Update BoundaryTests.java --- test/swen90006/machine/BoundaryTests.java | 678 +++++++++++++++++++++- 1 file changed, 658 insertions(+), 20 deletions(-) diff --git a/test/swen90006/machine/BoundaryTests.java b/test/swen90006/machine/BoundaryTests.java index 61ce1ca..3768819 100644 --- a/test/swen90006/machine/BoundaryTests.java +++ b/test/swen90006/machine/BoundaryTests.java @@ -34,35 +34,673 @@ public class BoundaryTests assertEquals(expected, actual); } - @Test public void anotherTest() + @Test public void B1_1() { - 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 FOR # OF INSTRUCTION 1 WITH RET. + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("RET R1"); + assertEquals( m.execute(lines1), 0); } - - //Test test opens a file and executes the machine - @Test public void aFileOpenTest() + + @Test public void B1_2() { - final List<String> lines = readInstructions("examples/array.s"); + + // TEST FOR # OF INSTRUCTION >1 WITH RET. Machine m = new Machine(); - assertEquals(m.execute(lines), 45); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R1 2"); + lines1.add("RET R1"); + assertEquals( m.execute(lines1), 2); + } + + + @Test(expected = NoReturnValueException.class) + public void B1_3() + throws Throwable +{ + // TEST FOR # OF INSTRUCTION 1 WITH NO RET. + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("ADD R1 R2 R3"); + m.execute(lines1); + +} + + @Test public void B2_1() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH ADD AND REGISTER VALUE VALID . + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R2 2"); + lines1.add("MOV R3 5"); + lines1.add("ADD R1 R2 R3"); + + + lines1.add("RET R1"); + + + assertEquals( m.execute(lines1), 7); + +} + + @Test public void B2_2() + + { + // TEST FOR # OF INSTRUCTION >1 WITH SUB AND REGISTER VALUE VALID . + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R2 2"); + lines1.add("MOV R3 5"); + lines1.add("SUB R1 R2 R3"); + lines1.add("RET R1"); + + + assertEquals( m.execute(lines1), -3); + + } + + + @Test public void B2_3() + + { + // TEST FOR # OF INSTRUCTION >1 WITH MUL AND REGISTER VALUE VALID . + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R2 2"); + lines1.add("MOV R3 5"); + lines1.add("MUL R1 R2 R3"); + lines1.add("RET R1"); + + + assertEquals( m.execute(lines1), 10); + } - //To test an exception, specify the expected exception after the @Test - @Test(expected = java.io.IOException.class) - public void anExceptionTest() - throws Throwable + @Test public void B2_4() + { - throw new java.io.IOException(); + // TEST FOR # OF INSTRUCTION >1 WITH div AND REGISTER VALUE VALID . + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R2 10"); + lines1.add("MOV R3 5"); + lines1.add("DIV R1 R2 R3"); + lines1.add("RET R1"); + + + assertEquals( m.execute(lines1), 2); + } + + @Test(expected = InvalidInstructionException.class) + public void B2_5() + throws Throwable + + { + // TEST FOR # OF INSTRUCTION >1 WITH in valid insrtuction + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOVED R2 2"); + lines1.add("MOV R3 5"); + lines1.add("MUL R1 R2 R3"); + lines1.add("RET R1"); + + + m.execute(lines1); + + } + + @Test(expected = InvalidInstructionException.class) + public void B3_1() + throws Throwable + + { + // TEST FOR # OF INSTRUCTION >1 WITH ADD AND REGISTER VALUE INVALID . + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("ADD R-1 R2 R3"); + + lines1.add("RET R1"); + + + m.execute(lines1); + + } + + @Test(expected = InvalidInstructionException.class) + public void B3_2() + throws Throwable + + { + // TEST FOR # OF INSTRUCTION >1 WITH ADD AND REGISTER VALUE INVALID . + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("ADD R32 R2 R3"); + + lines1.add("RET R1"); + + + m.execute(lines1); + + } + + + @Test public void B3_3() + + + { + // TEST FOR # OF INSTRUCTION >1 WITH ADD AND REGISTER VALUE VALID . + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("ADD R0 R2 R3"); + + lines1.add("RET R0"); + + assertEquals( m.execute(lines1), 0); + + } + +@Test public void B3_4() + + + { + // TEST FOR # OF INSTRUCTION >1 WITH ADD AND REGISTER VALUE VALID . + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("ADD R31 R2 R3"); + + lines1.add("RET R31"); + + assertEquals( m.execute(lines1), 0); + + } + + +@Test(expected = InvalidInstructionException.class) +public void B4_1() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE INVALID AND VAL VALID + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R32 34"); + m.execute(lines1); + +} + + +@Test public void B4_2() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE VALID AND VAL VALID ON POINT FOR VAL + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R31 -65535"); + lines1.add("RET R31"); + assertEquals( m.execute(lines1), -65535); + +} + +@Test public void B4_3() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE VALID AND VAL VALID ON POINT FOR VAL + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R31 65535"); + lines1.add("RET R31"); + assertEquals( m.execute(lines1), 65535); + +} + + +@Test(expected = InvalidInstructionException.class) +public void B4_4() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE inVALID AND VAL IN VALID OFF POINT FOR VAL + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R31 -65536"); + lines1.add("RET R31"); + m.execute(lines1); + +} +@Test(expected = InvalidInstructionException.class) +public void B4_5() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE inVALID AND VAL IN VALID OFF POINT FOR VAL + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R31 65536"); + lines1.add("RET R31"); + m.execute(lines1); + +} + + + +@Test(expected = InvalidInstructionException.class) +public void B5_1() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE INVALID OFF POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("STR R32 R45 -655"); + lines1.add("RET R31"); + m.execute(lines1); + +} + + +@Test(expected = InvalidInstructionException.class) +public void B5_2() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL INVALID OFF POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("STR R31 R4 -65536"); + lines1.add("RET R31"); + m.execute(lines1); + +} + +@Test(expected = InvalidInstructionException.class) +public void B5_3() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL INVALID OFF POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("STR R31 R4 65536"); + lines1.add("RET R31"); + m.execute(lines1); + +} + + +@Test public void B5_4() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL VALID; + //TESTING LDR FUNCTIONALITY & b+v inside the given range ON POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R1 5"); + lines1.add("MOV R4 65534"); + lines1.add("STR R4 1 R1"); + lines1.add("LDR R2 R4 1"); + + lines1.add("RET R2"); + assertEquals( m.execute(lines1), 5); + + +} + +@Test public void B5_5() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL VALID; + //TESTING LDR FUNCTIONALITY & b+v inside the given range ON POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R1 5"); + lines1.add("MOV R4 2"); + lines1.add("STR R4 -2 R1"); + lines1.add("LDR R2 R4 -2"); + + lines1.add("RET R2"); + assertEquals( m.execute(lines1), 5); + + +} + + +@Test public void B5_6() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL VALID + //TESTING LDR FUNCTIONALITY & b+v OUT SIDE the given range OFF POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R1 5"); + lines1.add("MOV R4 65535"); + lines1.add("STR R4 1 R1"); + lines1.add("LDR R2 R4 1"); + + lines1.add("RET R2"); + assertEquals( m.execute(lines1), 0); + + +} + + + +@Test public void B5_7() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL VALID + //TESTING LDR FUNCTIONALITY & b+v OUT SIDE the given range OFF POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add("MOV R1 5"); + lines1.add("MOV R4 -2"); + lines1.add("STR R4 1 R1"); + lines1.add("LDR R2 R4 1"); + + lines1.add("RET R2"); + assertEquals( m.execute(lines1), 0); + +} + +@Test(timeout = 5000) + public void b6_1() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH JMP vAL=1 ON POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add(" MOV R1 1"); + lines1.add(" JMP 1"); + lines1.add(" MOV R1 2"); + + + + lines1.add("RET R1"); + assertEquals( m.execute(lines1), 2); + + +} + + +@Test(timeout = 5000) +public void b6_8() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH JMP vAL=O ON POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add(" MOV R1 1"); + lines1.add(" JMP 0"); + lines1.add(" MOV R1 2"); + + + + lines1.add("RET R1"); + assertEquals( m.execute(lines1), 2); + + +} + +@Test(timeout = 5000) + public void b6_2() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH JMP vAL=1 + + //TESTING FUNCTIONALITY & VAL + PC IN SIDE the given range ON POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add(" MOV R1 1"); + lines1.add(" JMP 2"); + lines1.add(" MOV R1 3"); + lines1.add(" MOV R1 2"); + + + + lines1.add("RET R1"); + assertEquals( m.execute(lines1), 2); + + +} + + +@Test(timeout = 5000) + public void b6_3() + +{ + // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL +PC IS WITH IN THE RANGE + //TESTING FUNCTIONALITY & VAL + PC IN SIDE the given range ON POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add(" MOV R1 1"); + lines1.add(" MOV R2 2"); + lines1.add(" JMP 2"); + lines1.add("MOV R2 5"); + lines1.add("MOV R4 8"); + + + + + lines1.add("RET R4"); + assertEquals( m.execute(lines1), 8); + + +} + +@Test(timeout = 5000, expected = NoReturnValueException.class) +public void B6_4() +throws Throwable +{ + //TESTING FUNCTIONALITY & VAL + PC OUT SIDE the given range OFF POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + lines1.add(" MOV R1 1"); + lines1.add(" MOV R2 2"); + lines1.add(" JMP -3"); + lines1.add("RET R4"); + + m.execute(lines1); + +} + +@Test(timeout = 5000, expected = NoReturnValueException.class) +public void B6_5() +throws Throwable +{ + //TESTING FUNCTIONALITY & VAL + PC OUT SIDE the given range OFF POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + + + lines1.add(" MOV R4 2"); + lines1.add(" JMP 5"); + lines1.add(" MOV R5 2"); + lines1.add(" MOV R6 2"); + lines1.add(" MOV R7 2"); + lines1.add("RET R4"); + + m.execute(lines1); + +} + +@Test(timeout = 5000, expected = InvalidInstructionException.class) +public void B7_1() +throws Throwable +{ + + // TEST FOR # OF INSTRUCTION >1 WITH REGISTER VAL IN VALID OFF POINT + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + lines1.add(" JZ R32 1"); + lines1.add(" MOV R1 2"); + + + + lines1.add("RET R34"); + m.execute(lines1) ; + + +} + + + + + + +@Test (timeout = 5000) +public void b7_3() + +{ + // TEST FOR REGISTER 0 FOR JZ + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + lines1.add(" MOV R1 0"); + lines1.add(" MOV R2 2"); + lines1.add(" JZ R1 2"); + lines1.add(" MOV R1 2"); + lines1.add(" MOV R2 3"); + + + lines1.add("RET R1"); + lines1.add("RET R2"); + assertEquals( m.execute(lines1), 0); + + + + +} + +@Test(timeout = 5000) +public void b7_4() + +{ + // TEST FOR REGISTER != 0 FOR JZ + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + lines1.add(" MOV R2 2"); + lines1.add(" JZ R2 2"); + lines1.add(" MOV R1 1"); + lines1.add(" MOV R2 3"); + + + lines1.add("RET R1"); + assertEquals( m.execute(lines1), 1); + + + + +} + + + + + +@Test(timeout = 5000, expected = NoReturnValueException.class) +public void B7_5() +throws Throwable +{ + // TEST FOR JZ where pc is outside the given range .. off point + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + lines1.add("MOV R1 0"); + lines1.add(" MOV R2 2"); + lines1.add(" JZ R1 -3"); + lines1.add("RET R4"); + + m.execute(lines1); + +} + +@Test(timeout = 5000,expected = NoReturnValueException.class) +public void B7_6() +throws Throwable +{ + // TEST FOR JZ where pc is outside the given range .. off point + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + + + lines1.add(" MOV R1 0"); + lines1.add(" JZ R1 5"); + lines1.add(" MOV R5 2"); + lines1.add(" MOV R6 2"); + lines1.add(" MOV R7 2"); + lines1.add("RET R4"); + + m.execute(lines1); + +} + + +@Test(timeout = 5000,expected = NoReturnValueException.class) +public void B8_1() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION WITH NO RET. + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + + + lines1.add(" MOV R1 1"); + lines1.add(" JZ R1 2"); + lines1.add(" MOV R5 2"); + lines1.add(" MOV R6 2"); + lines1.add(" MOV R7 2"); + + + m.execute(lines1); + +} + + +@Test(timeout = 5000) +public void B8_2() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION WITH 1 RET. + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + + + lines1.add(" MOV R1 1"); + lines1.add(" JZ R1 2"); + lines1.add(" MOV R5 2"); + lines1.add(" RET R4"); + + assertEquals( m.execute(lines1), 0); + + + + m.execute(lines1); + +} + +@Test(timeout = 5000,expected = NoReturnValueException.class) +public void B8_3() +throws Throwable +{ + // TEST FOR # OF INSTRUCTION WITH 2 RET. + Machine m = new Machine(); + final List<String> lines1= new ArrayList<>(); + + + + lines1.add(" MOV R1 1"); + lines1.add(" JZ R1 2"); + lines1.add(" MOV R3 2"); + lines1.add(" RET R4"); + lines1.add(" RET R3"); + + + assertEquals( m.execute(lines1), 0); + +} - //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 -- GitLab