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)