def test_overflow(self):
val1 = memory.Value(255)
val2 = memory.Value(3)
self.assertEqual(self.alu.add(val1, val2), memory.Value(2))
self.assertTrue(self.alu.overflow_flag)
self.assertFalse(self.alu.zero_flag)
def test_read_neg(self):
value = memory.Value(-VALUE_0A_HEX)
addr = memory.Address(ADDR_20_HEX)
self.mem.write(addr, value)
value_expected = memory.Value(-VALUE_0A_HEX)
self.assertEqual(self.mem.read(addr), value_expected)
def test_zero(self):
val1 = memory.Value(255)
val2 = memory.Value(1)
self.assertEqual(self.alu.add(val1, val2), memory.Value(0))
self.assertTrue(self.alu.overflow_flag)
self.assertTrue(self.alu.zero_flag)
def test_add_neg_result(self):
val1 = memory.Value(-VALUE_10_HEX)
val2 = memory.Value(VALUE_0A_HEX)
result, carry = val1 + val2
self.assertEqual(result, memory.Value(-0x06))
self.assertFalse(carry)
def test_add_over(self):
val1 = memory.Value(0xf0)
val2 = memory.Value(0xf0)
result, carry = val1 + val2
self.assertEqual(result, memory.Value(0xe0))
self.assertTrue(carry)
def test_write_index(self):
value = memory.Value(0x0a)
addr = memory.Address(0x10)
index_val = memory.Value(0x10)
self.mem_if.write(addr, value, index=index_val)
read_value = self.mem_if.read(addr, index=index_val)
self.assertEqual(read_value, value)
def test_add_neg(self):
val1 = memory.Value(5)
val2 = memory.Value(-3)
result = self.alu.add(val1, val2)
self.assertEqual(result, memory.Value(2))
self.assertFalse(self.alu.overflow_flag)
self.assertFalse(self.alu.zero_flag)
def test_fetch_execute(self):
fake_obj = FakeInstruction()
self.decoder.op_codes[0x01] = fake_obj.instr
# The op code.
self.mem.write(memory.Address(0x10), memory.Value(0x01))
# The addr argument.
self.mem.write(memory.Address(0x11), memory.Value(0x22))
self.reg.ip = memory.Address(0x10)
self.decoder.fetch_execute()
self.assertEqual(self.reg.ip, memory.Address(0x12))
self.assertEqual(fake_obj.addr, memory.Address(0x22))
def test_addx(self):
self.reg.accum = VAL2
self.reg.idx = INDEX
self.mem_if.write(ADDR1, VAL1, index=INDEX)
self.instr.addx(ADDR1)
self.assertEqual(self.reg.accum, memory.Value(5))
def __init__(self):
"""Initialize the registers."""
self.accum = memory.Value(0)
self.ip = memory.Address(0)
self.idx = memory.Address(0)
self.run_flag = False
self.zerox_flag = False
def test_display_range(self):
value = memory.Value(VALUE_0A_HEX)
addr1 = memory.Address(ADDR_20_HEX - 1)
addr2 = memory.Address(ADDR_20_HEX + 2)
addr = memory.Address(ADDR_20_HEX)
self.mem.write(addr, value)
self.assertEqual(self.mem.display_range(addr1, addr2),
'0x1f 0x00\n0x20 0x0a\n0x21 0x00')
def test_add(self):
self.reg.accum = VAL2
self.instr.add(ADDR1)
self.assertEqual(self.reg.accum, memory.Value(5))
self.reg.run_flag = True
self.instr.halt(ADDR1)
self.assertFalse(self.reg.run_flag)
def test_is_printable(self):
self.assertFalse(memory.Value(0x01).is_printable())
self.assertTrue(memory.Value(0x21).is_printable())
self.assertTrue(memory.Value(0x50).is_printable())
self.assertTrue(memory.Value(0x65).is_printable())
self.assertFalse(memory.Value(0x7f).is_printable())
self.assertFalse(memory.Value(0xa0).is_printable())
def add(self, val1, val2):
"""Add two values and return the resulting sum value."""
val1_num = val1.get_num()
val2_num = val2.get_num()
total_num = val1_num + val2_num
if total_num > 255:
self.overflow_flag = True
total_num = total_num % 256
else:
self.overflow_flag = False
self.zero_flag = (total_num == 0)
return memory.Value(total_num)
def test_display_addr_not_printable(self):
value = memory.Value(VALUE_0A_HEX)
addr = memory.Address(ADDR_20_HEX)
self.mem.write(addr, value)
self.assertEqual(self.mem.display_printable(addr), '0x20 0x0a ')
def test_write_value(self):
value = memory.Value(0x0a)
addr = memory.Address(0x20)
self.mem_if.write(addr, value)
self.assertEqual(self.mem_if.read(addr), value)
def test_read_zero_value(self):
addr = memory.Address(0x20)
value = memory.Value(0)
self.assertEqual(self.mem_if.read(addr), value)
def test_negative(self):
value = memory.Value(-VALUE_0A_HEX)
self.assertEqual(value.hex(), '0x0a')
self.assertTrue(value.negative_flag)
def test_get_num_neg(self):
value = memory.Value(VALUE_0A_HEX)
value.negate()
num = value.get_num()
self.assertEqual(num, -VALUE_0A_HEX)
#!/usr/bin/env python3
# coding: utf-8
# © 2018 by Ken Guyton. All rights reserved.
"""Test the instruction decoder."""
import unittest
import cpu
import decoder
import memory
ADDR1 = memory.Address(0x10)
ADDR2 = memory.Address(0x20)
INDEX = memory.Value(0x05)
ADDR_IDX_1 = memory.Address(0x15)
ADDR_IDX_2 = memory.Address(0x25)
ZERO = memory.Value(0)
ONE = memory.Value(1)
VAL1 = memory.Value(2)
VAL2 = memory.Value(3)
class TestInstructions(unittest.TestCase):
def setUp(self):
self.reg = cpu.Registers()
self.mem = memory.Memory()
self.alu = cpu.ArithmeticLogicUnit()
self.mem_if = decoder.MemoryInterface(self.mem)
self.instr = decoder.Instructions(reg=self.reg,
def test_eq_zero_not(self):
value = memory.Value(VALUE_0A_HEX)
self.assertFalse(value.eq_zero())
def setUp(self):
self.value = memory.Value(VALUE_0A_HEX)
def test_eq_zero(self):
value = memory.Value(0)
self.assertTrue(value.eq_zero())
def test_copy_neg(self):
neg_value = memory.Value(-VALUE_0A_HEX)
neg_copy_value = neg_value.copy()
self.assertEqual(neg_copy_value, neg_value)
#!/usr/bin/env python3
# coding: utf-8
# © 2018 by Ken Guyton. All rights reserved.
"""Test the CPU."""
import unittest
import cpu
import decoder
import memory
VALUE_0A_HEX = 0x0a
ADDR_20_HEX = 0x20
SIZE = 255
ZERO_ADDR = memory.Address(0)
ZERO_VAL = memory.Value(0)
class TestRegisters(unittest.TestCase):
def setUp(self):
self.reg = cpu.Registers()
def test_create(self):
self.assertTrue(self.reg is not None)
def test_values(self):
self.assertEqual(self.reg.accum, ZERO_VAL)
self.assertEqual(self.reg.idx, ZERO_VAL)
self.assertEqual(self.reg.ip, ZERO_ADDR)
self.assertFalse(self.reg.run_flag)
def test_write_value(self):
value = memory.Value(VALUE_0A_HEX)
addr = memory.Address(ADDR_20_HEX)
self.mem.write(addr, value)
self.assertEqual(self.mem.read(addr), value)
def test_add(self):
result, carry = memory.Value(VALUE_0A_HEX) + memory.Value(VALUE_10_HEX)
self.assertEqual(result, memory.Value(0x1a))
self.assertFalse(carry)
def test_display_addr_printable(self):
value = memory.Value(0x43)
addr = memory.Address(ADDR_20_HEX)
self.mem.write(addr, value)
self.assertEqual(self.mem.display_printable(addr), '0x20 0x43 C')
def test_sub(self):
self.reg.accum = VAL2
self.instr.sub(ADDR1)
self.assertEqual(self.reg.accum, memory.Value(1))
def test_read_zero_value(self):
addr = memory.Address(ADDR_20_HEX)
value = memory.Value(0)
self.assertEqual(self.mem.read(addr), value)
