From c5ddf1407c3ebe944d0614698cfbb60cf44474ea Mon Sep 17 00:00:00 2001
From: Abdul Mateen Ahmad Khan <a.khan21@student.unimelb.edu.au>
Date: Sun, 2 Sep 2018 15:41:02 +1000
Subject: [PATCH] Update PartitioningTests.java
---
test/swen90006/machine/PartitioningTests.java | 702 +++++++++++++++++-
1 file changed, 677 insertions(+), 25 deletions(-)
diff --git a/test/swen90006/machine/PartitioningTests.java b/test/swen90006/machine/PartitioningTests.java
index 5494b44..c7c86a6 100644
--- a/test/swen90006/machine/PartitioningTests.java
+++ b/test/swen90006/machine/PartitioningTests.java
@@ -24,41 +24,693 @@ public class PartitioningTests
{
}
- //Any method annotation with "@Test" is executed as a test.
- @Test public void aTest()
+ @Test public void E1()
{
- //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 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 public void anotherTest()
+
+
+
+
+
+ @Test(expected = NoReturnValueException.class)
+ public void E2()
+ 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 E3()
+
+{
+ // 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 E6()
+
{
- 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 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 E7()
+
+ {
+ // 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);
+
+ }
+
+ @Test public void E8()
+
+ {
+ // 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 public void E9()
+
+ {
+ // TEST FOR # RET with 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 E4()
+ 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 R33 R2 R3");
+ lines1.add("RET R3");
+
+ m.execute(lines1);
+
+}
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E5()
+ 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-4 R2 R3");
+ lines1.add("RET R3");
+
+ m.execute(lines1);
+
+}
+
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E13()
+ throws Throwable
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE inVALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R34 34");
+ m.execute(lines1);
+
+}
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E14()
+ throws Throwable
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE inVALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R-1 34");
+ m.execute(lines1);
+
+}
+
+
+ @Test public void E10()
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE VALID AND VAL VALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R31 34");
+ lines1.add("RET R31");
+ assertEquals( m.execute(lines1), 34);
+
+}
- //Test test opens a file and executes the machine
- @Test public void aFileOpenTest()
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E11()
+ throws Throwable
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE VALID AND VAL INVALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R31 65538");
+ lines1.add("RET R31");
+ m.execute(lines1);
+
+}
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E12()
+ throws Throwable
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH MOV AND REGISTER VALUE VALID AND VAL INVALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R31 -65538");
+ lines1.add("RET R31");
+ m.execute(lines1);
+
+}
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E17()
+ throws Throwable
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE INVALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("STR R31 R45 -655");
+ lines1.add("RET R31");
+ m.execute(lines1);
+
+}
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E18()
+ throws Throwable
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE INVALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("STR R-31 R45 -655");
+ lines1.add("RET R31");
+ m.execute(lines1);
+
+}
+
+
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E19()
+ throws Throwable
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL INVALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("STR R31 R4 -655444");
+ lines1.add("RET R31");
+ m.execute(lines1);
+
+}
+
+
+ @Test(expected = InvalidInstructionException.class)
+ public void E20()
+ throws Throwable
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL INVALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("STR R31 R4 655444");
+ lines1.add("RET R31");
+ m.execute(lines1);
+
+}
+
+
+ @Test public void E15()
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL VALID;
+ //TESTING LDR FUNCTIONALITY & b+v inside the given range
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R1 5");
+ lines1.add("MOV R4 2");
+ lines1.add("STR R4 3 R1");
+ lines1.add("LDR R2 R4 3");
+
+ lines1.add("RET R2");
+ assertEquals( m.execute(lines1), 5);
+
+
+}
+
+ @Test public void E16_1()
+
{
- final List<String> lines = readInstructions("examples/array.s");
- Machine m = new Machine();
- assertEquals(m.execute(lines), 45);
+ // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL VALID;
+ //TESTING LDR FUNCTIONALITY & b+v less then 0
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R1 5");
+ lines1.add("MOV R4 -7");
+ lines1.add("STR R4 3 R1");
+ lines1.add("LDR R2 R4 3");
+
+ lines1.add("RET R2");
+ assertEquals( m.execute(lines1), 0);
+
+
}
- //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 E16_2()
+
{
- throw new java.io.IOException();
+ // TEST FOR # OF INSTRUCTION >1 WITH STR AND REGISTER VALUE VALID AND VAL VALID;
+ //TESTING LDR FUNCTIONALITY & b+v greater then 65535
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R1 5");
+ lines1.add("MOV R4 65535");
+ lines1.add("STR R4 78 R1");
+ lines1.add("LDR R2 R4 78");
+
+ lines1.add("RET R2");
+ assertEquals( m.execute(lines1), 0);
+
+
}
+
+
+
+
+
+
+
+
+@Test public void E21()
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH LDR AND REGISTER VALUE VALID AND VAL VALID;
+ //TESTING LDR FUNCTIONALITY & b+v inside the given range
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add("MOV R1 5");
+ lines1.add("MOV R4 2");
+ lines1.add("STR R4 3 R1");
+ lines1.add("LDR R2 R4 3");
+
+ lines1.add("RET R2");
+ assertEquals( m.execute(lines1), 5);
+
+
+}
+
+
+
+
+@Test (timeout = 5000)
+ public void E23()
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP vAL=1
+ 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 E22()
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP vAL=0
+ 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 E24()
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL +PC IS WITH IN THE RANGE
+ 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 R2 5");
+
+
+
+
+ lines1.add("RET R1");
+ assertEquals( m.execute(lines1), 1);
+
+
+}
+
+@Test(timeout = 5000, expected = NoReturnValueException.class)
+public void E25()
+throws Throwable
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL +PC IS LESS THEN 0
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOV R1 1");
+ lines1.add(" JMP -3");
+ lines1.add("RET R1");
+ m.execute(lines1);
+
+
+
+}
+
+@Test(timeout = 5000,expected = NoReturnValueException.class)
+public void E26()
+throws Throwable
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL +PC IS GRETER THEN N-1
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOV R1 1");
+ lines1.add(" JMP 79");
+ lines1.add("RET R1");
+ m.execute(lines1);
+
+
+
+}
+
+@Test(timeout = 5000,expected = InvalidInstructionException.class)
+public void E27()
+throws Throwable
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL IN VALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" JMP 7900000");
+ lines1.add("RET R1");
+ m.execute(lines1);
+
+
+
+}
+
+
+@Test(timeout = 5000, expected = InvalidInstructionException.class)
+public void E28()
+throws Throwable
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL IN VALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" JMP -678888");
+ lines1.add("RET R1");
+ m.execute(lines1);
+
+
+
+}
+
+
+@Test(timeout = 5000, expected = InvalidInstructionException.class)
+public void E29()
+throws Throwable
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JZ AND REGISTER IN VALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" JZ R56 2");
+ lines1.add("RET R1");
+ m.execute(lines1);
+
+
+
+}
+
+@Test(timeout = 5000,expected = InvalidInstructionException.class)
+public void E30()
+throws Throwable
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JZ AND REGISTER IN VALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" JZ R-4 2");
+ lines1.add("RET R1");
+ m.execute(lines1);
+
+
+
+}
+
+@Test(timeout = 5000,expected = InvalidInstructionException.class)
+public void E31()
+throws Throwable
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL IN VALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" JZ R5 2899898");
+ lines1.add("RET R1");
+ m.execute(lines1);
+
+
+
+}
+
+
+@Test(timeout = 5000,expected = InvalidInstructionException.class)
+public void E32()
+throws Throwable
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL IN VALID
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" JZ R5 -2899898");
+ lines1.add("RET R1");
+ m.execute(lines1);
+
+
+
+}
+
+
+@Test (timeout = 5000)
+public void E34()
+
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL VALID AND R1=0 AND VAL +PC WITH IN RANGE AND RET =1
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOV R1 0");
+ lines1.add(" JZ R1 2");
+ lines1.add(" MOV R1 3");
+ lines1.add(" RET R1");
+
+
+
+
+ assertEquals(m.execute(lines1),0);
+
+}
+@Test (timeout = 5000)
+public void E33()
+
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL VALID AND R1!=0
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOV R1 1");
+ lines1.add(" JZ R1 2");
+ lines1.add(" MOV R1 3");
+ lines1.add(" RET R1");
+
+
+
+
+ assertEquals(m.execute(lines1),3);
+
+
+
+}
+
+@Test(timeout = 5000, expected = NoReturnValueException.class)
+public void E35()
+throws Throwable
+
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL VALID AND R1=0 AND VAL +PC <0
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOV R1 0");
+ lines1.add(" JZ R1 -3");
+ lines1.add(" MOV R1 3");
+ lines1.add(" RET R1");
+
+
+
+
+ m.execute(lines1);
+
+
+
+}
+@Test(timeout = 5000, expected = NoReturnValueException.class)
+public void E36()
+throws Throwable
+
+
+{
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL VALID AND R1=0 AND VAL +PC >0
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOV R1 0");
+ lines1.add(" JZ R1 78");
+ lines1.add(" MOV R1 3");
+ lines1.add(" RET R1");
+
+
+
+
+ m.execute(lines1);
+}
+
+@Test(expected = InvalidInstructionException.class)
+public void E37()
+throws Throwable
+
+
+{
+ // TEST FOR INVALID INSTRUCTION
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOVTY R1 0");
+ lines1.add(" RET R1");
+
+
+
+
+ m.execute(lines1);
+}
+
+
+@Test (timeout = 5000)
+
+public void E38()
+
+
+{
+
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL VALID AND R1=0 AND VAL +PC WITH IN RANGE AND RET >1
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOV R1 0");
+ lines1.add(" JZ R1 2");
+ lines1.add(" MOV R2 3");
+ lines1.add(" MOV R4 3");
+ lines1.add(" RET R2");
+ lines1.add(" RET R2");
+
+
+
+
+ assertEquals(m.execute(lines1),0);
+
+
+
+}
+
+@Test( timeout = 5000 ,expected = NoReturnValueException.class)
+public void E39()
+throws Throwable
+
+{
+
+ // TEST FOR # OF INSTRUCTION >1 WITH JMP AND VAL VALID AND R1=0 AND VAL +PC WITH IN RANGE AND RET =0
+ Machine m = new Machine();
+ final List<String> lines1= new ArrayList<>();
+ lines1.add(" MOV R1 0");
+ lines1.add(" JZ R1 5");
+ lines1.add(" MOV R1 3");
+
+
+
+
+
+
+ m.execute(lines1);
+
+
+
+}
+
+
+
//This test should fail.
//To provide additional feedback when a test fails, an error message
--
GitLab