Skip to content
Snippets Groups Projects
Commit c5ddf140 authored by Abdul Mateen Ahmad Khan's avatar Abdul Mateen Ahmad Khan
Browse files

Update PartitioningTests.java

parent 06f30af5
No related branches found
No related tags found
No related merge requests found
...@@ -24,42 +24,694 @@ public class PartitioningTests ...@@ -24,42 +24,694 @@ public class PartitioningTests
{ {
} }
//Any method annotation with "@Test" is executed as a test. @Test public void E1()
@Test public void aTest()
{ {
//the assertEquals method used to check whether two values are
//equal, using the equals method // TEST FOR # OF INSTRUCTION 1 WITH RET.
final int expected = 2; Machine m = new Machine();
final int actual = 1 + 1; final List<String> lines1= new ArrayList<>();
assertEquals(expected, actual); lines1.add("RET R1");
assertEquals( m.execute(lines1), 0);
}
@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 anotherTest() @Test public void E6()
{ {
List<String> list = new ArrayList<String>(); // TEST FOR # OF INSTRUCTION >1 WITH SUB AND REGISTER VALUE VALID .
list.add("a"); Machine m = new Machine();
list.add("b"); 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);
//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() @Test public void E7()
{ {
final List<String> lines = readInstructions("examples/array.s"); // TEST FOR # OF INSTRUCTION >1 WITH MUL AND REGISTER VALUE VALID .
Machine m = new Machine(); Machine m = new Machine();
assertEquals(m.execute(lines), 45); 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 public void E8()
@Test(expected = java.io.IOException.class)
public void anExceptionTest() {
// 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 throws Throwable
{ {
throw new java.io.IOException(); // 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(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()
{
// 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);
}
@Test public void E16_2()
{
// 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. //This test should fail.
//To provide additional feedback when a test fails, an error message //To provide additional feedback when a test fails, an error message
//can be included //can be included
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment