def test_sza_zero(self):
self.reg.ip = ADDR1
self.alu.zero_flag = True
self.instr.sza(memory.Address(0x00))
addr2 = memory.Address(ADDR1.num + 2)
self.assertEqual(self.reg.ip, addr2)
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 __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 display_list(self, a_list, printable=False):
"""Display a list of address value tuple pairs."""
start_num = a_list[0][0]
end_num = a_list[-1][0] + 1
start_addr = memory.Address(start_num)
end_addr = memory.Address(end_num)
return self.mem.display_range(start_addr, end_addr, printable)
def test_read_index(self):
value = memory.Value(0x0a)
addr = memory.Address(0x10)
addr_idx = memory.Address(0x20)
index_val = memory.Value(0x10)
self.mem_if.write(addr_idx, value)
read_value = self.mem_if.read(addr, index=index_val)
self.assertEqual(read_value, value)
def test_szx_zero(self):
self.reg.ip = ADDR1
self.reg.zerox_flag = True
self.instr.szx(ZERO)
addr2 = memory.Address(ADDR1.num + 2)
self.assertEqual(self.reg.ip, addr2)
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_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 setUp(self):
self.addr = memory.Address(VALUE_0A_HEX)
def test_read_zero_value(self):
addr = memory.Address(ADDR_20_HEX)
value = memory.Value(0)
self.assertEqual(self.mem.read(addr), value)
def test_sza_not_zero(self):
self.reg.ip = ADDR1
self.alu.zero_flag = False
self.instr.sza(memory.Address(0x00))
self.assertEqual(self.reg.ip, ADDR1)
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)
#!/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_inc(self):
self.assertEqual(self.addr.inc(), memory.Address(VALUE_0A_HEX + 1))
#!/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_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_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 ')