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 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)
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 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)
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)
