class StoreTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
# mock state
self.cpu.state.a.set_value(77)
self.cpu.state.x.set_value(88)
self.cpu.state.y.set_value(99)
self.memory.set_content(100, 55)
def test_sta_change_mem(self):
opcode = 0x85
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[100])
self.assertEqual(self.memory.retrieve_content(100), 77)
def test_stx_change_mem(self):
opcode = 0x86
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[100])
self.assertEqual(self.memory.retrieve_content(100), 88)
def test_sty_change_mem(self):
opcode = 0x84
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[100])
self.assertEqual(self.memory.retrieve_content(100), 99)
class RolTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.set_content(0xA000, 0b11000000)
self.cpu.state.a.set_value(0b01000000)
def test_rol_accumulator_flags(self):
self.cpu.state.status.carry = True
inst = InstructionCollection.get_instruction(0x2A)
ret = inst.execute(self.memory, self.cpu, [])
self.assertEqual(self.cpu.state.a.get_value(), 0b10000001)
self.assertEqual(self.cpu.state.status.negative, True)
self.assertEqual(self.cpu.state.status.zero, False)
self.assertEqual(self.cpu.state.status.carry, False)
self.assertEqual(ret, None)
def test_rol_abs_flags(self):
params = [0, 0xA0]
self.cpu.state.status.carry = False
inst = InstructionCollection.get_instruction(0x2E)
ret = inst.execute(self.memory, self.cpu, params)
self.assertEqual(0xA000, ret)
self.assertEqual(self.memory.retrieve_content(0XA000), 0b10000000)
self.assertEqual(self.cpu.state.status.negative, True)
self.assertEqual(self.cpu.state.status.zero, False)
self.assertEqual(self.cpu.state.status.carry, True)
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
# mock state
self.cpu.state.a.set_value(77)
self.cpu.state.x.set_value(88)
self.cpu.state.y.set_value(99)
self.memory.set_content(100, 55)
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
# mock state
self.memory.set_content(100, 77)
self.memory.set_content(101, 0)
self.memory.set_content(102, 128)
self.cpu.state.a.set_value(1)
self.cpu.state.x.set_value(1)
self.cpu.state.y.set_value(1)
class LsrTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.set_content(100, 8)
self.memory.set_content(101, 1)
def test_lsr_accumulator(self):
self.cpu.state.a.set_value(4)
opcode = 0x4A
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(self.cpu.state.a.get_value(), 2)
self.assertFalse(self.cpu.state.status.negative)
def test_lsr_accumulator_status(self):
self.cpu.state.a.set_value(1)
opcode = 0x4A
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(self.cpu.state.a.get_value(), 0)
self.assertTrue(self.cpu.state.status.zero)
self.assertTrue(self.cpu.state.status.carry)
self.assertFalse(self.cpu.state.status.negative)
def test_lsr(self):
opcode = 0x46
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[100])
self.assertEqual(self.memory.retrieve_content(100), 4)
self.assertFalse(self.cpu.state.status.negative)
def test_lsr_status(self):
opcode = 0x46
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[101])
self.assertEqual(self.memory.retrieve_content(101), 0)
self.assertFalse(self.cpu.state.status.negative)
self.assertTrue(self.cpu.state.status.zero)
self.assertTrue(self.cpu.state.status.carry)
class AslTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.set_content(0, 0b10000000)
self.cpu.state.a.set_value(0b11000000)
def test_asl_accumulator_flags(self):
inst = InstructionCollection.get_instruction(0x0A)
ret = inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(self.cpu.state.status.negative, True)
self.assertEqual(self.cpu.state.status.zero, False)
self.assertEqual(self.cpu.state.status.carry, True)
self.assertEqual(self.cpu.state.a.get_value(), 0b10000000)
self.assertEqual(ret, None)
def test_asl_memory_ZeroPg_flags(self):
inst = InstructionCollection.get_instruction(0x06)
addr = inst.execute(memory=self.memory, cpu=self.cpu, params=[0])
self.assertEqual(self.cpu.state.status.negative, False)
self.assertEqual(self.cpu.state.status.zero, True)
self.assertEqual(self.cpu.state.status.carry, True)
self.assertEqual(self.memory.retrieve_content(0), 0)
self.assertEqual(addr, 0)
class StackInstTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.top = self.memory.stack.get_top()
def test_pha(self):
self.cpu.state.a.set_value(0xA)
opcode = 0x48
inst = InstructionCollection.get_instruction(opcode)
addr = inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(addr, self.top)
self.assertEqual(self.memory.stack.get_top(), self.top - 1)
self.assertEqual(0xA, self.memory.retrieve_content(self.top))
def test_pla(self):
self.cpu.state.a.set_value(0xA)
self.cpu.state.a.set_value(0)
self.test_pha()
opcode = 0x68
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(self.memory.stack.get_top(), self.top)
self.assertEqual(0xA, self.cpu.state.a.get_value())
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
self.cpu.state.pc.set_value(10)
class StackTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.stack = Stack(self.memory, self.cpu.state)
def test_push(self):
self.stack.push_val(77)
self.assertEqual(self.memory.retrieve_content(0x1FD), 77)
self.assertEqual(self.cpu.state.sp.get_value(), 0xFC)
def test_pop(self):
self.cpu.state.sp.set_value(0xFE)
self.memory.set_content(0x1FF, 88)
self.assertEqual(self.stack.pop_val(), 88)
self.assertEqual(self.cpu.state.sp.get_value(), 0xFF)
def test_mirror_ram_first_chunk(self):
addr = 0x312
value = 0xFA
self.memory.set_content(addr, value)
self.assertEqual(self.memory.retrieve_content(addr), value)
self.assertEqual(self.memory.retrieve_content(addr + 0x0800), value)
self.assertEqual(self.memory.retrieve_content(addr + 0x1000), value)
self.assertEqual(self.memory.retrieve_content(addr + 0x1800), value)
def test_mirror_ram_second_chunk(self):
addr = 0x0965
value = 0xFB
self.memory.set_content(addr, value)
self.assertEqual(self.memory.retrieve_content(addr), value)
self.assertEqual(self.memory.retrieve_content(addr - 0x0800), value)
self.assertEqual(self.memory.retrieve_content(addr + 0x0800), value)
self.assertEqual(self.memory.retrieve_content(addr + 0x1000), value)
def test_mirror_ram_third_chunk(self):
addr = 0x1158
value = 0xFC
self.memory.set_content(addr, value)
self.assertEqual(self.memory.retrieve_content(addr), value)
self.assertEqual(self.memory.retrieve_content(addr - 0x1000), value)
self.assertEqual(self.memory.retrieve_content(addr - 0x0800), value)
self.assertEqual(self.memory.retrieve_content(addr + 0x0800), value)
def test_mirror_ram_fourth_chunk(self):
addr = 0x1A34
value = 0xFD
self.memory.set_content(addr, value)
self.assertEqual(self.memory.retrieve_content(addr), value)
self.assertEqual(self.memory.retrieve_content(addr - 0x1800), value)
self.assertEqual(self.memory.retrieve_content(addr - 0x1000), value)
self.assertEqual(self.memory.retrieve_content(addr - 0x0800), value)
def test_ppu_mirror_zero(self):
addr = 0x2005
value = 0xFF
self.memory.set_content(addr, value)
self.assertEqual(self.memory.retrieve_content(addr), value)
self.assertEqual(self.memory.retrieve_content(addr + 8), value)
self.assertEqual(self.memory.retrieve_content(addr + 16), value)
def test_ppu_mirror_random(self):
addr = 0x3A87
value = 0xFF
ppu_addr_intended = 0x2007
self.memory.set_content(addr, value)
self.assertEqual(self.memory.retrieve_content(ppu_addr_intended),
value)
self.assertEqual(self.memory.retrieve_content(ppu_addr_intended + 8),
value)
self.assertEqual(self.memory.retrieve_content(ppu_addr_intended + 16),
value)
self.assertEqual(self.memory.retrieve_content(ppu_addr_intended + 16),
value)
self.assertEqual(self.memory.retrieve_content(ppu_addr_intended + 32),
value)
def test_solve_mirroring(self):
addr = 0x0700
self.assertEqual(addr, self.memory.solve_mirroring(0x0700))
self.assertEqual(addr, self.memory.solve_mirroring(0x0F00))
self.assertEqual(addr, self.memory.solve_mirroring(0x1700))
self.assertEqual(addr, self.memory.solve_mirroring(0x1F00))
self.assertNotEqual(addr, self.memory.solve_mirroring(0x2700))
def test_load_0xFFFF(self):
addr = 0xFFFF
a = self.memory.retrieve_content(0xFFFF)
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.stack = Stack(self.memory, self.cpu.state)
class InstructionAddressingTest(unittest.TestCase):
POSITION_PLACEHOLDER = 1
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
# memory Mock
self.memory.memory = [InstructionAddressingTest.POSITION_PLACEHOLDER] * Memory.MEMORY_LIMIT
def test_ImmediateAddr(self):
# 1 byte limit
immediate = 0b1010
processed_param = ImmediateAddr.calculate_unified_parameter([immediate], self.cpu, self.memory)
self.assertEqual(processed_param, immediate)
def test_ZeroPageAddr(self):
# 1 byte
zero_pg_addr = 0b1010
processed_param = ZeroPageAddr.calculate_unified_parameter([zero_pg_addr], self.cpu, self.memory)
self.assertEqual(processed_param, zero_pg_addr)
self.assertEqual(self.memory.retrieve_content(processed_param), InstructionAddressingTest.POSITION_PLACEHOLDER)
def test_AbsoluteAddr(self):
# 2 bytes
low_byte = 0b1010
high_byte = 0b1010
processed_param = AbsoluteAddr.calculate_unified_parameter([low_byte, high_byte], self.cpu, self.memory)
self.assertEqual(processed_param, 0b0000101000001010)
self.assertEqual(self.memory.retrieve_content(processed_param), InstructionAddressingTest.POSITION_PLACEHOLDER)
def test_ImpliedAddr(self):
self.assertEqual(ImpliedAddr.parameter_length, 0)
def test_AccumulatorAddr(self):
self.cpu.state.a.set_value(0b1010)
accum = AccumulatorAddr.calculate_unified_parameter([], self.cpu, self.memory)
self.assertEqual(0b1010, accum)
def test_ZeroPgDirectIndexedRegXAddr(self):
self.cpu.state.x.set_value(10)
zero_pg = 10
self.memory.set_content(20, 20)
unified_param = ZeroPgDirectIndexedRegXAddr.calculate_unified_parameter([zero_pg], self.cpu, self.memory)
self.assertEqual(unified_param, 20)
self.assertEqual(self.memory.retrieve_content(unified_param), 20)
def tets_ZeroPgDirectIndexedRegYAddr(self):
self.cpu.state.y.set_value(10)
zero_pg = 10
self.memory.set_content(20, 20)
unified_param = ZeroPgDirectIndexedRegYAddr.calculate_unified_parameter([zero_pg], self.cpu, self.memory)
self.assertEqual(unified_param, 20)
self.assertEqual(self.memory.retrieve_content(unified_param), 20)
def test_AbsDirectIndexedRegXAddr(self):
self.cpu.state.x.set_value(10)
low_byte = 0b1010
high_byte = 0b1010
self.memory.set_content(0b0000101000001010 + 10, 30)
unified_param = AbsDirectIndexedRegXAddr.calculate_unified_parameter([low_byte, high_byte], self.cpu,
self.memory)
self.assertEqual(unified_param, 0b0000101000001010 + 10)
self.assertEqual(self.memory.retrieve_content(unified_param), 30)
def test_AbsDirectIndexedRegYAddr(self):
self.cpu.state.y.set_value(10)
low_byte = 0b1010
high_byte = 0b1010
self.memory.set_content(0b0000101000001010 + 10, 30)
unified_param = AbsDirectIndexedRegYAddr.calculate_unified_parameter([low_byte, high_byte], self.cpu,
self.memory)
self.assertEqual(unified_param, 0b0000101000001010 + 10)
self.assertEqual(self.memory.retrieve_content(unified_param), 30)
def test_IndirectAddr(self):
self.memory.set_content(1, 10)
self.memory.set_content(2, 10)
low_byte = 1
high_byte = 0
unified_param = IndirectAddr.calculate_unified_parameter([low_byte, high_byte], self.cpu, self.memory)
self.assertEqual(unified_param, 0b0000101000001010)
# addition is used - i.e. the sum is always a zero-page address.
# eg. FF + 2 = 0001 not 0101 as you might expect.
# DON'T FORGET THIS WHEN EMULATING THIS MODE
def test_IndirectPreIndexedAddr(self):
self.cpu.state.x.set_value(2)
zero_pg = 0xFF
# addition = 0b1
self.memory.set_content(1, 3)
self.memory.set_content(2, 3)
unified_param = IndirectPreIndexedAddr.calculate_unified_parameter([zero_pg], self.cpu, self.memory)
self.assertEqual(unified_param, 0b1100000011)
def test_IndirectPostIndexedAddr(self):
self.cpu.state.y.set_value(10)
self.memory.set_content(1, 3)
self.memory.set_content(2, 3)
addr = 1
unified_param = IndirectPostIndexedAddr.calculate_unified_parameter([addr], self.cpu, self.memory)
self.assertEqual(unified_param, 0b1100000011 + 10)
def test_RelativeIndexedAddr(self):
# one byte movement offset (with signal)
offset = 0b11111011 # -5 in 2 complement
unified_param = RelativeIndexedAddr.calculate_unified_parameter([offset], self.cpu, self.memory)
self.assertEqual(unified_param, offset)
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
# memory Mock
self.memory.memory = [InstructionAddressingTest.POSITION_PLACEHOLDER] * Memory.MEMORY_LIMIT
class AddInstructionTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
def compare_flags(self, zero, carry, negative, overflow):
self.assertEqual(zero, self.cpu.state.status.zero)
self.assertEqual(carry, self.cpu.state.status.carry)
self.assertEqual(negative, self.cpu.state.status.negative)
self.assertEqual(overflow, self.cpu.state.status.overflow)
def test_add_overflow_sum_of_negatives_results_in_positive(self):
opcode = 0x69
test_value = 128
self.cpu.state.a.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(0, self.cpu.state.a.get_value())
self.compare_flags(zero=True, carry=True, negative=False, overflow=True)
def test_add_overflow_sum_of_positives_results_in_negative(self):
opcode = 0x69
test_value = 70
self.cpu.state.a.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(2 * test_value, self.cpu.state.a.get_value())
self.compare_flags(zero=False, carry=False, negative=True, overflow=True)
def test_add_immediate_address_negative(self):
opcode = 0x69
test_value = 200
self.cpu.state.a.set_value(1)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(test_value + 1, self.cpu.state.a.get_value())
self.compare_flags(zero=False, carry=False, negative=True, overflow=False)
def test_add_immediate_address_with_carry(self):
opcode = 0x69
test_value = 0
self.cpu.state.a.set_value(0)
self.cpu.state.status.carry = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(test_value + 1, self.cpu.state.a.get_value())
self.compare_flags(zero=False, carry=False, negative=False, overflow=False)
def test_add_immediate_address(self):
opcode = 0x69
test_value = 0
self.cpu.state.a.set_value(0)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(test_value, self.cpu.state.a.get_value())
self.compare_flags(zero=True, carry=False, negative=False, overflow=False)
def test_add_zero_page_address(self):
opcode = 0x65
test_value = 37
memory_position = 1
self.cpu.state.a.set_value(0)
self.memory.set_content(memory_position, test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[memory_position])
self.assertEqual(test_value, self.memory.retrieve_content(memory_position))
self.assertEqual(test_value, self.cpu.state.a.get_value())
self.compare_flags(zero=False, carry=False, negative=False, overflow=False)
class IncreaseTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
def test_inx_normal(self):
opcode = 232
test_value = 67
self.cpu.state.x.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(test_value + 1, self.cpu.state.x.get_value())
self.assertEqual(False, self.cpu.state.status.zero)
self.assertEqual(False, self.cpu.state.status.negative)
def test_inx_negative(self):
opcode = 232
test_value = 127
self.cpu.state.x.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(test_value + 1, self.cpu.state.x.get_value())
self.assertEqual(False, self.cpu.state.status.zero)
self.assertEqual(True, self.cpu.state.status.negative)
def test_inx_zero(self):
opcode = 232
test_value = 255
self.cpu.state.x.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(0, self.cpu.state.x.get_value())
self.assertEqual(True, self.cpu.state.status.zero)
self.assertEqual(False, self.cpu.state.status.negative)
def test_iny_normal(self):
opcode = 200
test_value = 34
self.cpu.state.y.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(test_value + 1, self.cpu.state.y.get_value())
self.assertEqual(False, self.cpu.state.status.zero)
self.assertEqual(False, self.cpu.state.status.negative)
def test_iny_negative(self):
opcode = 200
test_value = 127
self.cpu.state.y.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(test_value + 1, self.cpu.state.y.get_value())
self.assertEqual(False, self.cpu.state.status.zero)
self.assertEqual(True, self.cpu.state.status.negative)
def test_iny_zero(self):
opcode = 200
test_value = 255
self.cpu.state.y.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(0, self.cpu.state.y.get_value())
self.assertEqual(True, self.cpu.state.status.zero)
self.assertEqual(False, self.cpu.state.status.negative)
def test_inc_zero_page_zero(self):
opcode = 0xE6
test_value = 0xFF
memory_position = 1
self.memory.set_content(memory_position, test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(5, inst.get_cycles())
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[memory_position])
self.assertEqual(0, self.memory.retrieve_content(memory_position))
self.assertEqual(True, self.cpu.state.status.zero)
self.assertEqual(False, self.cpu.state.status.negative)
def test_inc_zero_page_negative(self):
opcode = 0xE6
test_value = 0b01111111
memory_position = 1
self.memory.set_content(memory_position, test_value)
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(5, inst.get_cycles())
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[memory_position])
self.assertEqual(128, self.memory.retrieve_content(memory_position))
self.assertEqual(False, self.cpu.state.status.zero)
self.assertEqual(True, self.cpu.state.status.negative)
class LoadTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
# mock state
self.memory.set_content(100, 77)
self.memory.set_content(101, 0)
self.memory.set_content(102, 128)
self.cpu.state.a.set_value(1)
self.cpu.state.x.set_value(1)
self.cpu.state.y.set_value(1)
def test_lda_change_a(self):
opcode = 0xAD
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x64, 0x00])
self.assertEqual(self.cpu.state.a.get_value(), 77)
def test_lda_change_a_immediate(self):
opcode = 0xA9
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[77])
self.assertEqual(self.cpu.state.a.get_value(), 77)
def test_lda_change_status(self):
opcode = 0xAD
inst = InstructionCollection.get_instruction(opcode)
# zero
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x65, 0x00])
self.assertTrue(self.cpu.state.status.zero)
self.assertFalse(self.cpu.state.status.negative)
# negative
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x66, 0x00])
self.assertFalse(self.cpu.state.status.zero)
self.assertTrue(self.cpu.state.status.negative)
def test_ldx_change_x(self):
opcode = 0xAE
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x64, 0x00])
self.assertEqual(self.cpu.state.x.get_value(), 77)
def test_ldx_change_x_immediate(self):
opcode = 0xA2
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[77])
self.assertEqual(self.cpu.state.x.get_value(), 77)
def test_ldx_change_status(self):
opcode = 0xAE
inst = InstructionCollection.get_instruction(opcode)
# zero
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x65, 0x00])
self.assertTrue(self.cpu.state.status.zero)
self.assertFalse(self.cpu.state.status.negative)
# negative
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x66, 0x00])
self.assertFalse(self.cpu.state.status.zero)
self.assertTrue(self.cpu.state.status.negative)
def test_ldy_change_y(self):
opcode = 0xAC
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x64, 0x00])
self.assertEqual(self.cpu.state.y.get_value(), 77)
def test_ldy_change_status(self):
opcode = 0xAC
inst = InstructionCollection.get_instruction(opcode)
# zero
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x65, 0x00])
self.assertTrue(self.cpu.state.status.zero)
self.assertFalse(self.cpu.state.status.negative)
# negative
inst.execute(memory=self.memory, cpu=self.cpu, params=[0x66, 0x00])
self.assertFalse(self.cpu.state.status.zero)
self.assertTrue(self.cpu.state.status.negative)
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.top = self.memory.stack.get_top()
class PatternTableTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
def test_pattern_table_simple(self):
self.memory.set_content(0x0000, 0x41)
self.memory.set_content(0x0001, 0xC2)
self.memory.set_content(0x0002, 0x44)
self.memory.set_content(0x0003, 0x48)
self.memory.set_content(0x0004, 0x10)
self.memory.set_content(0x0005, 0x20)
self.memory.set_content(0x0006, 0x40)
self.memory.set_content(0x0007, 0x80)
self.memory.set_content(0x0008, 0x01)
self.memory.set_content(0x0009, 0x02)
self.memory.set_content(0x000A, 0x04)
self.memory.set_content(0x000B, 0x08)
self.memory.set_content(0x000C, 0x16)
self.memory.set_content(0x000D, 0x21)
self.memory.set_content(0x000E, 0x42)
self.memory.set_content(0x000F, 0x87)
table = PatternTable()
table.get_all_tiles(self.memory)
pattern = table.pattern
self.assertEqual(256 * 64, len(pattern))
self.assertEqual(1, pattern[1])
self.assertEqual(3, pattern[7])
self.assertEqual(1, pattern[1 * 8 + 0])
self.assertEqual(1, pattern[1 * 8 + 1])
self.assertEqual(3, pattern[1 * 8 + 6])
self.assertEqual(1, pattern[2 * 8 + 1])
self.assertEqual(3, pattern[2 * 8 + 5])
self.assertEqual(1, pattern[3 * 8 + 1])
self.assertEqual(3, pattern[3 * 8 + 4])
self.assertEqual(3, pattern[4 * 8 + 3])
self.assertEqual(2, pattern[4 * 8 + 5])
self.assertEqual(2, pattern[4 * 8 + 6])
self.assertEqual(3, pattern[5 * 8 + 2])
self.assertEqual(2, pattern[5 * 8 + 7])
self.assertEqual(3, pattern[6 * 8 + 1])
self.assertEqual(2, pattern[6 * 8 + 6])
self.assertEqual(3, pattern[7 * 8 + 0])
self.assertEqual(2, pattern[7 * 8 + 5])
self.assertEqual(2, pattern[7 * 8 + 6])
self.assertEqual(2, pattern[7 * 8 + 7])
class BranchInstructionTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
self.cpu.state.pc.set_value(10)
def test_bcc_changing_pc(self):
opcode = 0x90
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.carry = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value + test_value, self.cpu.state.pc.get_value())
def test_bcc_maintaining_pc(self):
opcode = 0x90
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.carry = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value, self.cpu.state.pc.get_value())
def test_bcs_changing_pc(self):
opcode = 0xB0
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.carry = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value + test_value, self.cpu.state.pc.get_value())
def test_bcs_maintaining_pc(self):
opcode = 0xB0
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.carry = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value, self.cpu.state.pc.get_value())
def test_beq_changing_pc(self):
opcode = 0xF0
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.zero = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value + test_value, self.cpu.state.pc.get_value())
def test_beq_maintaining_pc(self):
opcode = 0xF0
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.zero = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value, self.cpu.state.pc.get_value())
def test_bne_changing_pc(self):
opcode = 0xD0
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.zero = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value + test_value, self.cpu.state.pc.get_value())
def test_bne_maintaining_pc(self):
opcode = 0xD0
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.zero = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value, self.cpu.state.pc.get_value())
def test_bmi_changing_pc(self):
opcode = 0x30
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.negative = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value + test_value, self.cpu.state.pc.get_value())
def test_bmi_maintaining_pc(self):
opcode = 0x30
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.negative = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value, self.cpu.state.pc.get_value())
def test_bpl_changing_pc(self):
opcode = 0x10
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.negative = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value + test_value, self.cpu.state.pc.get_value())
def test_bpl_maintaining_pc(self):
opcode = 0x10
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.negative = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value, self.cpu.state.pc.get_value())
def test_bvc_changing_pc(self):
opcode = 0x50
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.overflow = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value + test_value, self.cpu.state.pc.get_value())
def test_bvc_maintaining_pc(self):
opcode = 0x50
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.overflow = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value, self.cpu.state.pc.get_value())
def test_bvs_changing_pc(self):
opcode = 0x70
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.overflow = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value + test_value, self.cpu.state.pc.get_value())
def test_bvs_maintaining_pc(self):
opcode = 0x70
old_value = self.cpu.state.pc.get_value()
test_value = 124
self.cpu.state.status.overflow = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value, self.cpu.state.pc.get_value())
def test_branch_negative_value(self):
opcode = 0x70
old_value = self.cpu.state.pc.get_value()
test_value = 255
self.cpu.state.status.overflow = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(old_value - 1, self.cpu.state.pc.get_value())
def test_jump_absolute(self):
opcode = 0x4C
test_value = 74
params = [8, 10]
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=params)
self.assertEqual(0b0000101000001000, self.cpu.state.pc.get_value())
def test_jump_indirect(self):
opcode = 0x6C
test_value = 2
params = [1, 0]
self.memory.set_content(1, 8)
self.memory.set_content(2, 10)
self.memory.set_content(0b0000101000001000, test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=params)
self.assertEqual(0b0000101000001000, self.cpu.state.pc.get_value())
def test_jsr(self):
stack_top = self.memory.stack.get_top()
self.cpu.state.pc.set_value(0xAA00)
params = [00, 0xAA]
# 0xAA00 -1 = 0b 10101001 11111111
inst = InstructionCollection.get_instruction(0x20)
inst.execute(self.memory, self.cpu, params)
self.assertEqual(0xAA00, self.cpu.state.pc.get_value())
self.assertEqual(self.memory.retrieve_content(self.memory.stack.get_top() + 1), 0b11111111)
self.assertEqual(self.memory.retrieve_content(self.memory.stack.get_top() + 2), 0b10101001)
class EorInstructionTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
def compare_flags(self, zero, carry, negative, overflow):
self.assertEqual(zero, self.cpu.state.status.zero)
self.assertEqual(carry, self.cpu.state.status.carry)
self.assertEqual(negative, self.cpu.state.status.negative)
self.assertEqual(overflow, self.cpu.state.status.overflow)
def test_eor_immediate_address_zero(self):
opcode = 0x49
test_value = 126
self.cpu.state.a.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(0, self.cpu.state.a.get_value())
self.compare_flags(zero=True,
carry=False,
negative=False,
overflow=False)
def test_eor_immediate_address_negative(self):
opcode = 0x49
test_value = 255
self.cpu.state.a.set_value(127)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(128, self.cpu.state.a.get_value())
self.compare_flags(zero=False,
carry=False,
negative=True,
overflow=False)
def test_eor_immediate_address(self):
opcode = 0x49
test_value = 126
self.cpu.state.a.set_value(127)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(1, self.cpu.state.a.get_value())
self.compare_flags(zero=False,
carry=False,
negative=False,
overflow=False)
def test_eor_zero_page_address(self):
opcode = 0x45
test_value = 98
memory_position = 166
self.cpu.state.a.set_value(test_value)
self.memory.set_content(memory_position, test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory,
cpu=self.cpu,
params=[memory_position])
self.assertEqual(0, self.cpu.state.a.get_value())
self.assertEqual(test_value,
self.memory.retrieve_content(memory_position))
self.compare_flags(zero=True,
carry=False,
negative=False,
overflow=False)
class BitInstructionTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
def compare_flags(self, zero, carry, negative, overflow):
self.assertEqual(zero, self.cpu.state.status.zero)
self.assertEqual(carry, self.cpu.state.status.carry)
self.assertEqual(negative, self.cpu.state.status.negative)
self.assertEqual(overflow, self.cpu.state.status.overflow)
def test_bit_zero_page_address_zero_flag(self):
opcode = 0x24
test_value = 8
memory_position = 33
self.cpu.state.a.set_value(7)
self.memory.set_content(memory_position, test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory,
cpu=self.cpu,
params=[memory_position])
self.assertEqual(7, self.cpu.state.a.get_value())
self.assertEqual(test_value,
self.memory.retrieve_content(memory_position))
self.compare_flags(zero=True,
carry=False,
negative=False,
overflow=False)
def test_bit_zero_page_address_negative_flag(self):
opcode = 0x24
test_value = 140
memory_position = 43
self.cpu.state.a.set_value(128)
self.memory.set_content(memory_position, test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory,
cpu=self.cpu,
params=[memory_position])
self.assertEqual(128, self.cpu.state.a.get_value())
self.assertEqual(test_value,
self.memory.retrieve_content(memory_position))
self.compare_flags(zero=False,
carry=False,
negative=True,
overflow=False)
def test_bit_zero_page_address_overflow_flag(self):
opcode = 0x24
test_value = 0x42
memory_position = 53
self.cpu.state.a.set_value(10)
self.memory.set_content(memory_position, test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory,
cpu=self.cpu,
params=[memory_position])
self.assertEqual(10, self.cpu.state.a.get_value())
self.assertEqual(test_value,
self.memory.retrieve_content(memory_position))
self.compare_flags(zero=False,
carry=False,
negative=False,
overflow=True)
def test_bit_absolute_address_all_flags(self):
opcode = 0x2C
test_value = 254
memory_position = 0b0000100000001010
low_byte = 0b1010
high_byte = 0b1000
self.cpu.state.a.set_value(1)
self.memory.set_content(memory_position, test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory,
cpu=self.cpu,
params=[low_byte, high_byte])
self.assertEqual(1, self.cpu.state.a.get_value())
self.assertEqual(test_value,
self.memory.retrieve_content(memory_position))
self.compare_flags(zero=True,
carry=False,
negative=True,
overflow=True)
class FlagInstructionTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
def test_clc(self):
opcode = 24
self.cpu.state.status.carry = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(opcode, inst.opcode)
self.assertEqual(False, self.cpu.state.status.carry)
def test_sec(self):
opcode = 56
self.cpu.state.status.carry = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(opcode, inst.opcode)
self.assertEqual(True, self.cpu.state.status.carry)
def test_cli(self):
opcode = 88
self.cpu.state.status.interrupt = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(opcode, inst.opcode)
self.assertEqual(False, self.cpu.state.status.interrupt)
def test_sei(self):
opcode = 120
self.cpu.state.status.interrupt = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(opcode, inst.opcode)
self.assertEqual(True, self.cpu.state.status.interrupt)
def test_clv(self):
opcode = 184
self.cpu.state.status.overflow = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(opcode, inst.opcode)
self.assertEqual(False, self.cpu.state.status.overflow)
def test_cld(self):
opcode = 216
self.cpu.state.status.decimal = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(opcode, inst.opcode)
self.assertEqual(False, self.cpu.state.status.decimal)
def test_sed(self):
opcode = 248
self.cpu.state.status.decimal = False
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[])
self.assertEqual(opcode, inst.opcode)
self.assertEqual(True, self.cpu.state.status.decimal)
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.set_content(100, 8)
self.memory.set_content(101, 1)
class CompareInstructionTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
def compare_flags(self, zero, carry, negative):
self.assertEqual(zero, self.cpu.state.status.zero)
self.assertEqual(carry, self.cpu.state.status.carry)
self.assertEqual(negative, self.cpu.state.status.negative)
def test_cpx_compare_equals(self):
opcode = 0xE0
test_value = 12
self.cpu.state.x.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.compare_flags(zero=True, carry=True, negative=False)
def test_cpx_compare_negative(self):
opcode = 0xE0
test_value = 34
self.cpu.state.y.set_value(test_value - 1)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.compare_flags(zero=False, carry=False, negative=True)
def test_cpx_compare_carry_only(self):
opcode = 0xE0
test_value = 126
compare_value = 74
self.cpu.state.x.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[compare_value])
self.compare_flags(zero=False, carry=True, negative=False)
def test_cpy_compare_equals(self):
opcode = 0xC0
test_value = 65
self.cpu.state.y.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.compare_flags(zero=True, carry=True, negative=False)
def test_cpy_compare_negative(self):
opcode = 0xC0
test_value = 72
self.cpu.state.y.set_value(test_value - 1)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.compare_flags(zero=False, carry=False, negative=True)
def test_cpy_compare_carry_only(self):
opcode = 0xC0
test_value = 126
compare_value = 74
self.cpu.state.y.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[compare_value])
self.compare_flags(zero=False, carry=True, negative=False)
def test_cmp_compare_equals(self):
opcode = 0xC9
test_value = 65
self.cpu.state.a.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.compare_flags(zero=True, carry=True, negative=False)
def test_cmp_compare_negative(self):
opcode = 0xC9
test_value = 72
self.cpu.state.a.set_value(test_value - 1)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.compare_flags(zero=False, carry=False, negative=True)
def test_cmp_compare_carry_only(self):
opcode = 0xC9
test_value = 126
compare_value = 74
self.cpu.state.a.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[compare_value])
self.compare_flags(zero=False, carry=True, negative=False)
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.set_content(0xA000, 0b11000000)
self.cpu.state.a.set_value(0b01000000)
class SubInstructionTest(unittest.TestCase):
def setUp(self):
self.cpu = CPU()
self.memory = Memory(self.cpu)
self.memory.reset()
def compare_flags(self, zero, carry, negative, overflow):
self.assertEqual(zero, self.cpu.state.status.zero)
self.assertEqual(carry, self.cpu.state.status.carry)
self.assertEqual(negative, self.cpu.state.status.negative)
self.assertEqual(overflow, self.cpu.state.status.overflow)
def test_sub_one_goes_from_negative_to_positive_overflow(self):
opcode = 0xE9
sub_value = 1
test_value = 128
self.cpu.state.a.set_value(test_value)
self.cpu.state.status.carry = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[sub_value])
self.assertEqual(test_value - sub_value, self.cpu.state.a.get_value())
self.compare_flags(zero=False, carry=True, negative=False, overflow=True)
def test_sub_immediate_address_negative_without_carry(self):
opcode = 0xE9
test_value = 0
self.cpu.state.a.set_value(test_value)
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(255, self.cpu.state.a.get_value())
self.compare_flags(zero=False, carry=False, negative=True, overflow=False)
def test_sub_immediate_address_with_carry(self):
opcode = 0xE9
sub_value = 3
test_value = 65
self.cpu.state.a.set_value(test_value)
self.cpu.state.status.carry = True
inst = InstructionCollection.get_instruction(opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[sub_value])
self.assertEqual(test_value - sub_value, self.cpu.state.a.get_value())
self.compare_flags(zero=False, carry=True, negative=False, overflow=False)
def test_sub_immediate_address(self):
opcode = 0xE9
test_value = 0
self.cpu.state.a.set_value(test_value)
self.cpu.state.status.carry = True
inst = InstructionCollection.get_instruction(opcode)
self.assertEqual(2, inst.get_cycles())
self.assertEqual(opcode, inst.opcode)
inst.execute(memory=self.memory, cpu=self.cpu, params=[test_value])
self.assertEqual(test_value, self.cpu.state.a.get_value())
self.compare_flags(zero=True, carry=True, negative=False, overflow=False)
