mirror of https://github.com/irmen/ksim65.git
6221 lines
174 KiB
Kotlin
6221 lines
174 KiB
Kotlin
import org.junit.jupiter.api.Disabled
|
|
import org.junit.jupiter.api.TestInstance
|
|
import razorvine.ksim65.*
|
|
import razorvine.ksim65.components.*
|
|
import kotlin.test.*
|
|
|
|
/*
|
|
|
|
Unit test suite adapted from Py65 https://github.com/mnaberez/py65
|
|
|
|
Copyright (c) 2008-2018, Mike Naberezny and contributors.
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice, this
|
|
list of conditions and the following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
* Neither the name of the copyright holder nor the names of its
|
|
contributors may be used to endorse or promote products derived from
|
|
this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
@TestInstance(TestInstance.Lifecycle.PER_METHOD)
|
|
abstract class TestCommon6502 {
|
|
// Tests common to 6502-based microprocessors
|
|
|
|
val mpu: Cpu6502
|
|
val memory = Ram(0, 0xffff)
|
|
val bus = Bus()
|
|
|
|
abstract fun createCpu(): Cpu6502
|
|
|
|
init {
|
|
mpu = this.createCpu()
|
|
bus.add(mpu)
|
|
bus.add(memory)
|
|
memory.fill(0xaa)
|
|
memory[Cpu6502.RESET_vector] = 0
|
|
memory[Cpu6502.RESET_vector + 1] = 0
|
|
mpu.reset()
|
|
mpu.regP.I = false // allow interrupts again
|
|
}
|
|
|
|
companion object {
|
|
// processor flags
|
|
const val fNEGATIVE = 128
|
|
const val fOVERFLOW = 64
|
|
const val fUNUSED = 32
|
|
const val fBREAK = 16
|
|
const val fDECIMAL = 8
|
|
const val fINTERRUPT = 4
|
|
const val fZERO = 2
|
|
const val fCARRY = 1
|
|
}
|
|
|
|
// test helpers
|
|
fun writeMem(memory: MemMappedComponent, startAddress: Address, data: Iterable<UByte>) {
|
|
var addr = startAddress
|
|
data.forEach { memory[addr++] = it }
|
|
}
|
|
|
|
|
|
// Reset
|
|
@Test
|
|
fun test_reset_sets_registers_to_initial_states() {
|
|
|
|
mpu.reset()
|
|
assertEquals(0xFD, mpu.regSP)
|
|
assertEquals(0, mpu.regA)
|
|
assertEquals(0, mpu.regX)
|
|
assertEquals(0, mpu.regY)
|
|
assertTrue(mpu.regP.I) // the other status flags are undefined after reset
|
|
}
|
|
|
|
// ADC Absolute
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_carry_clear_in_accumulator_zeroes() {
|
|
mpu.regA = 0
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
// assertEquals(0x10000, memory.size)
|
|
|
|
memory[0xC000] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_carry_set_in_accumulator_zero() {
|
|
mpu.regA = 0
|
|
mpu.regP.C = true
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
memory[0xC000] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_carry_clear_in_no_carry_clear_out() {
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
memory[0xC000] = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_carry_clear_in_carry_set_out() {
|
|
mpu.regA = 0x02
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
memory[0xC000] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_overflow_clr_no_carry_01_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
memory[0xC000] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_overflow_clr_no_carry_01_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
memory[0xC000] = 0xff
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_overflow_set_no_carry_7f_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x7f
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
memory[0xC000] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_overflow_set_no_carry_80_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x80
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
memory[0xC000] = 0xff
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x7f, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_absolute_overflow_set_on_40_plus_40() {
|
|
mpu.regP.V = false
|
|
mpu.regA = 0x40
|
|
// $0000 ADC $C000
|
|
writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0))
|
|
memory[0xC000] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ADC Zero Page
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_carry_clear_in_accumulator_zeroes() {
|
|
mpu.regA = 0
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_carry_set_in_accumulator_zero() {
|
|
mpu.regA = 0
|
|
mpu.regP.C = true
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_carry_clear_in_no_carry_clear_out() {
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_carry_clear_in_carry_set_out() {
|
|
mpu.regA = 0x02
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_overflow_clr_no_carry_01_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_overflow_clr_no_carry_01_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0xff
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_overflow_set_no_carry_7f_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x7f
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_overflow_set_no_carry_80_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x80
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0xff
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x7f, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_overflow_set_on_40_plus_40() {
|
|
mpu.regA = 0x40
|
|
mpu.regP.V = false
|
|
// $0000 ADC $00B0
|
|
writeMem(memory, 0x0000, listOf(0x65, 0xB0))
|
|
memory[0x00B0] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ADC Immediate
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_carry_clear_in_accumulator_zeroes() {
|
|
mpu.regA = 0
|
|
// $0000 ADC #$00
|
|
writeMem(memory, 0x0000, listOf(0x69, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_carry_set_in_accumulator_zero() {
|
|
mpu.regA = 0
|
|
mpu.regP.C = true
|
|
// $0000 ADC #$00
|
|
writeMem(memory, 0x0000, listOf(0x69, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_carry_clear_in_no_carry_clear_out() {
|
|
mpu.regA = 0x01
|
|
// $0000 ADC #$FE
|
|
writeMem(memory, 0x0000, listOf(0x69, 0xFE))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_carry_clear_in_carry_set_out() {
|
|
mpu.regA = 0x02
|
|
// $0000 ADC #$FF
|
|
writeMem(memory, 0x0000, listOf(0x69, 0xFF))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_overflow_clr_no_carry_01_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC #$01
|
|
writeMem(memory, 0x000, listOf(0x69, 0x01))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_overflow_clr_no_carry_01_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC #$FF
|
|
writeMem(memory, 0x000, listOf(0x69, 0xff))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_overflow_set_no_carry_7f_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x7f
|
|
// $0000 ADC #$01
|
|
writeMem(memory, 0x000, listOf(0x69, 0x01))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_overflow_set_no_carry_80_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x80
|
|
// $0000 ADC #$FF
|
|
writeMem(memory, 0x000, listOf(0x69, 0xff))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x7f, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_immediate_overflow_set_on_40_plus_40() {
|
|
mpu.regA = 0x40
|
|
// $0000 ADC #$40
|
|
writeMem(memory, 0x0000, listOf(0x69, 0x40))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_on_immediate_79_plus_00_carry_set() {
|
|
mpu.regP.D = true
|
|
mpu.regP.C = true
|
|
mpu.regA = 0x79
|
|
// $0000 ADC #$00
|
|
writeMem(memory, 0x0000, listOf(0x69, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_on_immediate_6f_plus_00_carry_set() {
|
|
mpu.regP.D = true
|
|
mpu.regP.C = true
|
|
mpu.regA = 0x6f
|
|
// $0000 ADC #$00
|
|
writeMem(memory, 0x0000, listOf(0x69, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x76, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
// ADC Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_carry_clear_in_accumulator_zeroes() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_carry_set_in_accumulator_zero() {
|
|
mpu.regA = 0
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_carry_clear_in_no_carry_clear_out() {
|
|
mpu.regA = 0x01
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_carry_clear_in_carry_set_out() {
|
|
mpu.regA = 0x02
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_overflow_clr_no_carry_01_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_overflow_clr_no_carry_01_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0xff
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_overflow_set_no_carry_7f_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x7f
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_overflow_set_no_carry_80_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x80
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0xff
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x7f, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_x_overflow_set_on_40_plus_40() {
|
|
mpu.regP.V = false
|
|
mpu.regA = 0x40
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $C000,X
|
|
writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regX] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ADC Absolute, Y-Indexed
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_carry_clear_in_accumulator_zeroes() {
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_carry_set_in_accumulator_zero() {
|
|
mpu.regA = 0
|
|
mpu.regY = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_carry_clear_in_no_carry_clear_out() {
|
|
mpu.regA = 0x01
|
|
mpu.regY = 0x03
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_carry_clear_in_carry_set_out() {
|
|
mpu.regA = 0x02
|
|
mpu.regY = 0x03
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_overflow_clr_no_carry_01_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_overflow_clr_no_carry_01_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_overflow_set_no_carry_7f_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x7f
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_overflow_set_no_carry_80_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x80
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x7f, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_abs_y_overflow_set_on_40_plus_40() {
|
|
mpu.regP.V = false
|
|
mpu.regA = 0x40
|
|
mpu.regY = 0x03
|
|
// $0000 ADC $C000,Y
|
|
writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0))
|
|
memory[0xC000 + mpu.regY] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ADC Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_carry_clear_in_accumulator_zeroes() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_carry_set_in_accumulator_zero() {
|
|
mpu.regA = 0
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_carry_clear_in_no_carry_clear_out() {
|
|
mpu.regA = 0x01
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_carry_clear_in_carry_set_out() {
|
|
mpu.regA = 0x02
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_overflow_clr_no_carry_01_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_overflow_clr_no_carry_01_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_overflow_set_no_carry_7f_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x7f
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_overflow_set_no_carry_80_plus_ff() {
|
|
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x80
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xff
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x7f, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_zp_x_overflow_set_on_40_plus_40() {
|
|
mpu.regP.V = false
|
|
mpu.regA = 0x40
|
|
mpu.regX = 0x03
|
|
// $0000 ADC $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x75, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ADC Indirect, Indexed (X)
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_carry_clear_in_accumulator_zeroes() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_carry_set_in_accumulator_zero() {
|
|
mpu.regA = 0
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_carry_clear_in_no_carry_clear_out() {
|
|
mpu.regA = 0x01
|
|
mpu.regX = 0x03
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_carry_clear_in_carry_set_out() {
|
|
mpu.regA = 0x02
|
|
mpu.regX = 0x03
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_overflow_clr_no_carry_01_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
mpu.regX = 0x03
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_overflow_clr_no_carry_01_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
mpu.regX = 0x03
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_overflow_set_no_carry_7f_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x7f
|
|
mpu.regX = 0x03
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_overflow_set_no_carry_80_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x80
|
|
mpu.regX = 0x03
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x7f, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_ind_indexed_overflow_set_on_40_plus_40() {
|
|
mpu.regP.V = false
|
|
mpu.regA = 0x40
|
|
mpu.regX = 0x03
|
|
// $0000 ADC ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x61, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ADC Indexed, Indirect (Y)
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_carry_clear_in_accumulator_zeroes() {
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_carry_set_in_accumulator_zero() {
|
|
mpu.regA = 0
|
|
mpu.regY = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_carry_clear_in_no_carry_clear_out() {
|
|
mpu.regA = 0x01
|
|
mpu.regY = 0x03
|
|
// $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_carry_clear_in_carry_set_out() {
|
|
mpu.regA = 0x02
|
|
mpu.regY = 0x03
|
|
// $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_overflow_clr_no_carry_01_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
mpu.regY = 0x03
|
|
// $0000 $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_overflow_clr_no_carry_01_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x01
|
|
mpu.regY = 0x03
|
|
// $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_overflow_set_no_carry_7f_plus_01() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x7f
|
|
mpu.regY = 0x03
|
|
// $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_overflow_set_no_carry_80_plus_ff() {
|
|
mpu.regP.C = false
|
|
mpu.regA = 0x80
|
|
mpu.regY = 0x03
|
|
// $0000 $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x7f, mpu.regA)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_adc_bcd_off_indexed_ind_overflow_set_on_40_plus_40() {
|
|
mpu.regP.V = false
|
|
mpu.regA = 0x40
|
|
mpu.regY = 0x03
|
|
// $0000 ADC ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x71, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertTrue(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// AND (Absolute)
|
|
|
|
@Test
|
|
fun test_and_absolute_all_zeros_setting_zero_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 AND $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x2D, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_and_absolute_zeros_and_ones_setting_negative_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 AND $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x2D, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// AND (Absolute)
|
|
|
|
@Test
|
|
fun test_and_zp_all_zeros_setting_zero_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 AND $0010
|
|
writeMem(memory, 0x0000, listOf(0x25, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_and_zp_zeros_and_ones_setting_negative_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 AND $0010
|
|
writeMem(memory, 0x0000, listOf(0x25, 0x10))
|
|
memory[0x0010] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// AND (Immediate)
|
|
|
|
@Test
|
|
fun test_and_immediate_all_zeros_setting_zero_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 AND #$00
|
|
writeMem(memory, 0x0000, listOf(0x29, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_and_immediate_zeros_and_ones_setting_negative_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 AND #$AA
|
|
writeMem(memory, 0x0000, listOf(0x29, 0xAA))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// AND (Absolute, X-Indexed)
|
|
|
|
@Test
|
|
fun test_and_abs_x_all_zeros_setting_zero_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 AND $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x3d, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_and_abs_x_zeros_and_ones_setting_negative_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 AND $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x3d, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// AND (Absolute, Y-Indexed)
|
|
|
|
@Test
|
|
fun test_and_abs_y_all_zeros_setting_zero_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 AND $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x39, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_and_abs_y_zeros_and_ones_setting_negative_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 AND $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x39, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// AND Indirect, Indexed (X)
|
|
|
|
@Test
|
|
fun test_and_ind_indexed_x_all_zeros_setting_zero_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 AND ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x21, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_and_ind_indexed_x_zeros_and_ones_setting_negative_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 AND ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x21, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// AND Indexed, Indirect (Y)
|
|
|
|
@Test
|
|
fun test_and_indexed_ind_y_all_zeros_setting_zero_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 AND ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x31, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_and_indexed_ind_y_zeros_and_ones_setting_negative_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 AND ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x31, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// AND Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_and_zp_x_all_zeros_setting_zero_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 AND $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x35, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_and_zp_x_all_zeros_and_ones_setting_negative_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 AND $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x35, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ASL Accumulator
|
|
|
|
@Test
|
|
fun test_asl_accumulator_sets_z_flag() {
|
|
mpu.regA = 0x00
|
|
// $0000 ASL A
|
|
memory[0x0000] = 0x0A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_accumulator_sets_n_flag() {
|
|
mpu.regA = 0x40
|
|
// $0000 ASL A
|
|
memory[0x0000] = 0x0A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_accumulator_shifts_out_zero() {
|
|
mpu.regA = 0x7F
|
|
// $0000 ASL A
|
|
memory[0x0000] = 0x0A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xFE, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_accumulator_shifts_out_one() {
|
|
mpu.regA = 0xFF
|
|
// $0000 ASL A
|
|
memory[0x0000] = 0x0A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xFE, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_accumulator_80_sets_z_flag() {
|
|
mpu.regA = 0x80
|
|
mpu.regP.Z = false
|
|
// $0000 ASL A
|
|
memory[0x0000] = 0x0A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
// ASL Absolute
|
|
|
|
@Test
|
|
fun test_asl_absolute_sets_z_flag() {
|
|
// $0000 ASL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x0E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_absolute_sets_n_flag() {
|
|
// $0000 ASL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x0E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, memory[0xABCD])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_absolute_shifts_out_zero() {
|
|
mpu.regA = 0xAA
|
|
// $0000 ASL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x0E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertEquals(0xFE, memory[0xABCD])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_absolute_shifts_out_one() {
|
|
mpu.regA = 0xAA
|
|
// $0000 ASL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x0E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertEquals(0xFE, memory[0xABCD])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ASL Zero Page
|
|
|
|
@Test
|
|
fun test_asl_zp_sets_z_flag() {
|
|
// $0000 ASL $0010
|
|
writeMem(memory, 0x0000, listOf(0x06, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_zp_sets_n_flag() {
|
|
// $0000 ASL $0010
|
|
writeMem(memory, 0x0000, listOf(0x06, 0x10))
|
|
memory[0x0010] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, memory[0x0010])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_zp_shifts_out_zero() {
|
|
mpu.regA = 0xAA
|
|
// $0000 ASL $0010
|
|
writeMem(memory, 0x0000, listOf(0x06, 0x10))
|
|
memory[0x0010] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertEquals(0xFE, memory[0x0010])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_zp_shifts_out_one() {
|
|
mpu.regA = 0xAA
|
|
// $0000 ASL $0010
|
|
writeMem(memory, 0x0000, listOf(0x06, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertEquals(0xFE, memory[0x0010])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ASL Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_asl_abs_x_indexed_sets_z_flag() {
|
|
mpu.regX = 0x03
|
|
// $0000 ASL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x1E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_abs_x_indexed_sets_n_flag() {
|
|
mpu.regX = 0x03
|
|
// $0000 ASL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x1E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_abs_x_indexed_shifts_out_zero() {
|
|
mpu.regA = 0xAA
|
|
mpu.regX = 0x03
|
|
// $0000 ASL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x1E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertEquals(0xFE, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_abs_x_indexed_shifts_out_one() {
|
|
mpu.regA = 0xAA
|
|
mpu.regX = 0x03
|
|
// $0000 ASL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x1E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertEquals(0xFE, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ASL Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_asl_zp_x_indexed_sets_z_flag() {
|
|
mpu.regX = 0x03
|
|
// $0000 ASL $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x16, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_zp_x_indexed_sets_n_flag() {
|
|
mpu.regX = 0x03
|
|
// $0000 ASL $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x16, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_zp_x_indexed_shifts_out_zero() {
|
|
mpu.regX = 0x03
|
|
mpu.regA = 0xAA
|
|
// $0000 ASL $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x16, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertEquals(0xFE, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_asl_zp_x_indexed_shifts_out_one() {
|
|
mpu.regX = 0x03
|
|
mpu.regA = 0xAA
|
|
// $0000 ASL $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x16, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regA)
|
|
assertEquals(0xFE, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// BCC
|
|
|
|
@Test
|
|
fun test_bcc_carry_clear_branches_relative_forward() {
|
|
mpu.regP.C = false
|
|
// $0000 BCC +6
|
|
writeMem(memory, 0x0000, listOf(0x90, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002 + 0x06, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bcc_carry_clear_branches_relative_backward() {
|
|
mpu.regP.C = false
|
|
mpu.regPC = 0x0050
|
|
val rel = 256 + (-6) // two's complement of 6
|
|
// $0000 BCC -6
|
|
writeMem(memory, 0x0050, listOf(0x90, rel.toShort()))
|
|
mpu.step()
|
|
assertEquals(0x0052 - 6, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bcc_carry_set_does_not_branch() {
|
|
mpu.regP.C = true
|
|
// $0000 BCC +6
|
|
writeMem(memory, 0x0000, listOf(0x90, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
}
|
|
|
|
// BCS
|
|
|
|
@Test
|
|
fun test_bcs_carry_set_branches_relative_forward() {
|
|
mpu.regP.C = true
|
|
// $0000 BCS +6
|
|
writeMem(memory, 0x0000, listOf(0xB0, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002 + 0x06, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bcs_carry_set_branches_relative_backward() {
|
|
mpu.regP.C = true
|
|
mpu.regPC = 0x0050
|
|
val rel = 256 + (-6) // two's complement of 6
|
|
// $0000 BCS -6
|
|
writeMem(memory, 0x0050, listOf(0xB0, rel.toShort()))
|
|
mpu.step()
|
|
assertEquals(0x0052 - 6, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bcs_carry_clear_does_not_branch() {
|
|
mpu.regP.C = false
|
|
// $0000 BCS +6
|
|
writeMem(memory, 0x0000, listOf(0xB0, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
}
|
|
|
|
// BEQ
|
|
|
|
@Test
|
|
fun test_beq_zero_set_branches_relative_forward() {
|
|
mpu.regP.Z = true
|
|
// $0000 BEQ +6
|
|
writeMem(memory, 0x0000, listOf(0xF0, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002 + 0x06, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_beq_zero_set_branches_relative_backward() {
|
|
mpu.regP.Z = true
|
|
mpu.regPC = 0x0050
|
|
val rel = 256 + (-6) // two's complement of 6
|
|
// $0000 BEQ -6
|
|
writeMem(memory, 0x0050, listOf(0xF0, rel.toShort()))
|
|
mpu.step()
|
|
assertEquals(0x0052 - 6, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_beq_zero_clear_does_not_branch() {
|
|
mpu.regP.Z = false
|
|
// $0000 BEQ +6
|
|
writeMem(memory, 0x0000, listOf(0xF0, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
}
|
|
|
|
// BIT (Absolute)
|
|
|
|
@Test
|
|
fun test_bit_abs_copies_bit_7_of_memory_to_n_flag_when_0() {
|
|
mpu.regP.N = false
|
|
// $0000 BIT $FEED
|
|
writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE))
|
|
memory[0xFEED] = 0xFF
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_abs_copies_bit_7_of_memory_to_n_flag_when_1() {
|
|
mpu.regP.N = true
|
|
// $0000 BIT $FEED
|
|
writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE))
|
|
memory[0xFEED] = 0x00
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_abs_copies_bit_6_of_memory_to_v_flag_when_0() {
|
|
mpu.regP.V = false
|
|
// $0000 BIT $FEED
|
|
writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE))
|
|
memory[0xFEED] = 0xFF
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_abs_copies_bit_6_of_memory_to_v_flag_when_1() {
|
|
mpu.regP.V = true
|
|
// $0000 BIT $FEED
|
|
writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE))
|
|
memory[0xFEED] = 0x00
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_abs_stores_result_of_and_in_z_preserves_a_when_1() {
|
|
mpu.regP.Z = false
|
|
// $0000 BIT $FEED
|
|
writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE))
|
|
memory[0xFEED] = 0x00
|
|
mpu.regA = 0x01
|
|
mpu.step()
|
|
assertTrue(mpu.regP.Z)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertEquals(0x00, memory[0xFEED])
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_abs_stores_result_of_and_when_nonzero_in_z_preserves_a() {
|
|
mpu.regP.Z = true
|
|
// $0000 BIT $FEED
|
|
writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE))
|
|
memory[0xFEED] = 0x01
|
|
mpu.regA = 0x01
|
|
mpu.step()
|
|
assertFalse(mpu.regP.Z) // result of AND is non-zero
|
|
assertEquals(0x01, mpu.regA)
|
|
assertEquals(0x01, memory[0xFEED])
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_abs_stores_result_of_and_when_zero_in_z_preserves_a() {
|
|
mpu.regP.Z = false
|
|
// $0000 BIT $FEED
|
|
writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE))
|
|
memory[0xFEED] = 0x00
|
|
mpu.regA = 0x01
|
|
mpu.step()
|
|
assertTrue(mpu.regP.Z) // result of AND is zero
|
|
assertEquals(0x01, mpu.regA)
|
|
assertEquals(0x00, memory[0xFEED])
|
|
}
|
|
|
|
// BIT (Zero Page)
|
|
|
|
@Test
|
|
fun test_bit_zp_copies_bit_7_of_memory_to_n_flag_when_0() {
|
|
mpu.regP.N = false
|
|
// $0000 BIT $0010
|
|
writeMem(memory, 0x0000, listOf(0x24, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(11L, mpu.totalCycles)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_zp_copies_bit_7_of_memory_to_n_flag_when_1() {
|
|
mpu.regP.N = true
|
|
// $0000 BIT $0010
|
|
writeMem(memory, 0x0000, listOf(0x24, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(11L, mpu.totalCycles)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_zp_copies_bit_6_of_memory_to_v_flag_when_0() {
|
|
mpu.regP.V = false
|
|
// $0000 BIT $0010
|
|
writeMem(memory, 0x0000, listOf(0x24, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(11L, mpu.totalCycles)
|
|
assertTrue(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_zp_copies_bit_6_of_memory_to_v_flag_when_1() {
|
|
mpu.regP.V = true
|
|
// $0000 BIT $0010
|
|
writeMem(memory, 0x0000, listOf(0x24, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(11L, mpu.totalCycles)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_zp_stores_result_of_and_in_z_preserves_a_when_1() {
|
|
mpu.regP.Z = false
|
|
// $0000 BIT $0010
|
|
writeMem(memory, 0x0000, listOf(0x24, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.regA = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(11L, mpu.totalCycles)
|
|
assertTrue(mpu.regP.Z)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertEquals(0x00, memory[0x0010])
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_zp_stores_result_of_and_when_nonzero_in_z_preserves_a() {
|
|
mpu.regP.Z = true
|
|
// $0000 BIT $0010
|
|
writeMem(memory, 0x0000, listOf(0x24, 0x10))
|
|
memory[0x0010] = 0x01
|
|
mpu.regA = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(11L, mpu.totalCycles)
|
|
assertFalse(mpu.regP.Z) // result of AND is non-zero
|
|
assertEquals(0x01, mpu.regA)
|
|
assertEquals(0x01, memory[0x0010])
|
|
}
|
|
|
|
@Test
|
|
fun test_bit_zp_stores_result_of_and_when_zero_in_z_preserves_a() {
|
|
mpu.regP.Z = false
|
|
// $0000 BIT $0010
|
|
writeMem(memory, 0x0000, listOf(0x24, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.regA = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(11L, mpu.totalCycles)
|
|
assertTrue(mpu.regP.Z) // result of AND is zero
|
|
assertEquals(0x01, mpu.regA)
|
|
assertEquals(0x00, memory[0x0010])
|
|
}
|
|
|
|
// BMI
|
|
|
|
@Test
|
|
fun test_bmi_negative_set_branches_relative_forward() {
|
|
mpu.regP.N = true
|
|
// $0000 BMI +06
|
|
writeMem(memory, 0x0000, listOf(0x30, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002 + 0x06, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bmi_negative_set_branches_relative_backward() {
|
|
mpu.regP.N = true
|
|
mpu.regPC = 0x0050
|
|
// $0000 BMI -6
|
|
val rel = 256 + (-6) // two's complement of 6
|
|
writeMem(memory, 0x0050, listOf(0x30, rel.toShort()))
|
|
mpu.step()
|
|
assertEquals(0x0052 - 6, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bmi_negative_clear_does_not_branch() {
|
|
mpu.regP.N = false
|
|
// $0000 BEQ +6
|
|
writeMem(memory, 0x0000, listOf(0x30, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
}
|
|
|
|
// BNE
|
|
|
|
@Test
|
|
fun test_bne_zero_clear_branches_relative_forward() {
|
|
mpu.regP.Z = false
|
|
// $0000 BNE +6
|
|
writeMem(memory, 0x0000, listOf(0xD0, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002 + 0x06, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bne_zero_clear_branches_relative_backward() {
|
|
mpu.regP.Z = false
|
|
mpu.regPC = 0x0050
|
|
// $0050 BNE -6
|
|
val rel = 256 + (-6) // two's complement of 6
|
|
writeMem(memory, 0x0050, listOf(0xD0, rel.toShort()))
|
|
mpu.step()
|
|
assertEquals(0x0052 - 6, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bne_zero_set_does_not_branch() {
|
|
mpu.regP.Z = true
|
|
// $0000 BNE +6
|
|
writeMem(memory, 0x0000, listOf(0xD0, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
}
|
|
|
|
// BPL
|
|
|
|
@Test
|
|
fun test_bpl_negative_clear_branches_relative_forward() {
|
|
mpu.regP.N = false
|
|
// $0000 BPL +06
|
|
writeMem(memory, 0x0000, listOf(0x10, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002 + 0x06, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bpl_negative_clear_branches_relative_backward() {
|
|
mpu.regP.N = false
|
|
mpu.regPC = 0x0050
|
|
// $0050 BPL -6
|
|
val rel = 256 + (-6) // two's complement of 6
|
|
writeMem(memory, 0x0050, listOf(0x10, rel.toShort()))
|
|
mpu.step()
|
|
assertEquals(0x0052 - 6, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bpl_negative_set_does_not_branch() {
|
|
mpu.regP.N = true
|
|
// $0000 BPL +6
|
|
writeMem(memory, 0x0000, listOf(0x10, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
}
|
|
|
|
// BRK
|
|
|
|
@Test
|
|
fun test_brk_pushes_pc_plus_2_and_status_then_sets_pc_to_irq_vector() {
|
|
writeMem(memory, 0xFFFE, listOf(0xCD, 0xAB))
|
|
mpu.regSP = 0xff
|
|
mpu.regP.I = false
|
|
// $C000 BRK
|
|
memory[0xC000] = 0x00
|
|
mpu.regPC = 0xC000
|
|
mpu.step()
|
|
assertEquals(0xABCD, mpu.regPC)
|
|
|
|
assertEquals(0xFC, mpu.regSP)
|
|
assertEquals(0xC0, memory[0x1FF]) // PCH
|
|
assertEquals(0x02, memory[0x1FE]) // PCL
|
|
assertEquals(fBREAK or fUNUSED, memory[0x1FD].toInt(), "Status on stack should have no I flag")
|
|
assertEquals(fBREAK or fUNUSED or fINTERRUPT, mpu.regP.asInt())
|
|
}
|
|
|
|
// BVC
|
|
|
|
@Test
|
|
fun test_bvc_overflow_clear_branches_relative_forward() {
|
|
mpu.regP.V = false
|
|
// $0000 BVC +6
|
|
writeMem(memory, 0x0000, listOf(0x50, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002 + 0x06, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bvc_overflow_clear_branches_relative_backward() {
|
|
mpu.regP.V = false
|
|
mpu.regPC = 0x0050
|
|
val rel = 256 + (-6) // two's complement of 6
|
|
// $0050 BVC -6
|
|
writeMem(memory, 0x0050, listOf(0x50, rel.toShort()))
|
|
mpu.step()
|
|
assertEquals(0x0052 - 6, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bvc_overflow_set_does_not_branch() {
|
|
mpu.regP.V = true
|
|
// $0000 BVC +6
|
|
writeMem(memory, 0x0000, listOf(0x50, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
}
|
|
|
|
// BVS
|
|
|
|
@Test
|
|
fun test_bvs_overflow_set_branches_relative_forward() {
|
|
mpu.regP.V = true
|
|
// $0000 BVS +6
|
|
writeMem(memory, 0x0000, listOf(0x70, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002 + 0x06, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bvs_overflow_set_branches_relative_backward() {
|
|
mpu.regP.V = true
|
|
mpu.regPC = 0x0050
|
|
val rel = 256 + (-6) // two's complement of 6
|
|
// $0050 BVS -6
|
|
writeMem(memory, 0x0050, listOf(0x70, rel.toShort()))
|
|
mpu.step()
|
|
assertEquals(0x0052 - 6, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_bvs_overflow_clear_does_not_branch() {
|
|
mpu.regP.V = false
|
|
// $0000 BVS +6
|
|
writeMem(memory, 0x0000, listOf(0x70, 0x06))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
}
|
|
|
|
// CLC
|
|
|
|
@Test
|
|
fun test_clc_clears_carry_flag() {
|
|
mpu.regP.C = true
|
|
// $0000 CLC
|
|
memory[0x0000] = 0x18
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
// CLD
|
|
|
|
@Test
|
|
fun test_cld_clears_decimal_flag() {
|
|
mpu.regP.D = true
|
|
// $0000 CLD
|
|
memory[0x0000] = 0xD8
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertFalse(mpu.regP.D)
|
|
}
|
|
|
|
// CLI
|
|
@Test
|
|
fun test_cli_clears_interrupt_mask_flag() {
|
|
mpu.regP.I = true
|
|
// $0000 CLI
|
|
memory[0x0000] = 0x58
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertFalse(mpu.regP.I)
|
|
}
|
|
|
|
// CLV
|
|
@Test
|
|
fun test_clv_clears_overflow_flag() {
|
|
mpu.regP.V = true
|
|
// $0000 CLV
|
|
memory[0x0000] = 0xB8
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
// Compare instructions
|
|
|
|
// See http://6502.org/tutorials/compare_instructions.html
|
|
// and http://www.6502.org/tutorials/compare_beyond.html
|
|
// Cheat sheet:
|
|
// - Comparison is actually subtraction "register - memory"
|
|
// - Z contains equality result (1 equal, 0 not equal)
|
|
// - C contains result of unsigned comparison (0 if A<m, 1 if A>=m)
|
|
// - N holds MSB of subtraction result (*NOT* of signed subtraction)
|
|
// - V is not affected by comparison
|
|
// - D has no effect on comparison
|
|
|
|
// CMP Immediate
|
|
@Test
|
|
fun test_cmp_imm_sets_zero_carry_clears_neg_flags_if_equal() {
|
|
// Comparison: A == m
|
|
// $0000 CMP #10 , A will be 10
|
|
writeMem(memory, 0x0000, listOf(0xC9, 10))
|
|
mpu.regA = 10
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_cmp_imm_clears_zero_carry_takes_neg_if_less_unsigned() {
|
|
// Comparison: A < m (unsigned)
|
|
// $0000 CMP #10 , A will be 1
|
|
writeMem(memory, 0x0000, listOf(0xC9, 10))
|
|
mpu.regA = 1
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertTrue(mpu.regP.N) // 0x01-0x0A=0xF7
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_cmp_imm_clears_zero_sets_carry_takes_neg_if_less_signed() {
|
|
// Comparison: A < #nn (signed), A negative
|
|
// $0000 CMP #1, A will be -1 (0xFF)
|
|
writeMem(memory, 0x0000, listOf(0xC9, 1))
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertTrue(mpu.regP.N) // 0xFF-0x01=0xFE
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C) // A>m unsigned
|
|
}
|
|
|
|
@Test
|
|
fun test_cmp_imm_clears_zero_carry_takes_neg_if_less_signed_nega() {
|
|
// Comparison: A < m (signed), A and m both negative
|
|
// $0000 CMP #0xFF (-1), A will be -2 (0xFE)
|
|
writeMem(memory, 0x0000, listOf(0xC9, 0xFF))
|
|
mpu.regA = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertTrue(mpu.regP.N) // 0xFE-0xFF=0xFF
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C) // A<m unsigned
|
|
}
|
|
|
|
@Test
|
|
fun test_cmp_imm_clears_zero_sets_carry_takes_neg_if_more_unsigned() {
|
|
// Comparison: A > m (unsigned)
|
|
// $0000 CMP #1 , A will be 10
|
|
writeMem(memory, 0x0000, listOf(0xC9, 1))
|
|
mpu.regA = 10
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertFalse(mpu.regP.N) // 0x0A-0x01 = 0x09
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C) // A>m unsigned
|
|
}
|
|
|
|
@Test
|
|
fun test_cmp_imm_clears_zero_carry_takes_neg_if_more_signed() {
|
|
// Comparison: A > m (signed), memory negative
|
|
// $0000 CMP #$FF (-1), A will be 2
|
|
writeMem(memory, 0x0000, listOf(0xC9, 0xFF))
|
|
mpu.regA = 2
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertFalse(mpu.regP.N) // 0x02-0xFF=0x01
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C) // A<m unsigned
|
|
}
|
|
|
|
@Test
|
|
fun test_cmp_imm_clears_zero_carry_takes_neg_if_more_signed_nega() {
|
|
// Comparison: A > m (signed), A and m both negative
|
|
// $0000 CMP #$FE (-2), A will be -1 (0xFF)
|
|
writeMem(memory, 0x0000, listOf(0xC9, 0xFE))
|
|
mpu.regA = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertFalse(mpu.regP.N) // 0xFF-0xFE=0x01
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C) // A>m unsigned
|
|
}
|
|
|
|
// CPX Immediate
|
|
|
|
@Test
|
|
fun test_cpx_imm_sets_zero_carry_clears_neg_flags_if_equal() {
|
|
// Comparison: X == m
|
|
// $0000 CPX #$20
|
|
writeMem(memory, 0x0000, listOf(0xE0, 0x20))
|
|
mpu.regX = 0x20
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertTrue(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// CPY Immediate
|
|
|
|
@Test
|
|
fun test_cpy_imm_sets_zero_carry_clears_neg_flags_if_equal() {
|
|
// Comparison: Y == m
|
|
// $0000 CPY #$30
|
|
writeMem(memory, 0x0000, listOf(0xC0, 0x30))
|
|
mpu.regY = 0x30
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertTrue(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// DEC Absolute
|
|
@Test
|
|
fun test_dec_abs_decrements_memory() {
|
|
// $0000 DEC 0xABCD
|
|
writeMem(memory, 0x0000, listOf(0xCE, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x10
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x0F, memory[0xABCD])
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_dec_abs_below_00_rolls_over_and_sets_negative_flag() {
|
|
// $0000 DEC 0xABCD
|
|
writeMem(memory, 0x0000, listOf(0xCE, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xABCD])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_dec_abs_sets_zero_flag_when_decrementing_to_zero() {
|
|
// $0000 DEC 0xABCD
|
|
writeMem(memory, 0x0000, listOf(0xCE, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// DEC Zero Page
|
|
|
|
@Test
|
|
fun test_dec_zp_decrements_memory() {
|
|
// $0000 DEC 0x0010
|
|
writeMem(memory, 0x0000, listOf(0xC6, 0x10))
|
|
memory[0x0010] = 0x10
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x0F, memory[0x0010])
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_dec_zp_below_00_rolls_over_and_sets_negative_flag() {
|
|
// $0000 DEC 0x0010
|
|
writeMem(memory, 0x0000, listOf(0xC6, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0x0010])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_dec_zp_sets_zero_flag_when_decrementing_to_zero() {
|
|
// $0000 DEC 0x0010
|
|
writeMem(memory, 0x0000, listOf(0xC6, 0x10))
|
|
memory[0x0010] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// DEC Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_dec_abs_x_decrements_memory() {
|
|
// $0000 DEC 0xABCD,X
|
|
writeMem(memory, 0x0000, listOf(0xDE, 0xCD, 0xAB))
|
|
mpu.regX = 0x03
|
|
memory[0xABCD + mpu.regX] = 0x10
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x0F, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_dec_abs_x_below_00_rolls_over_and_sets_negative_flag() {
|
|
// $0000 DEC 0xABCD,X
|
|
writeMem(memory, 0x0000, listOf(0xDE, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_dec_abs_x_sets_zero_flag_when_decrementing_to_zero() {
|
|
// $0000 DEC 0xABCD,X
|
|
writeMem(memory, 0x0000, listOf(0xDE, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// DEC Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_dec_zp_x_decrements_memory() {
|
|
// $0000 DEC 0x0010,X
|
|
writeMem(memory, 0x0000, listOf(0xD6, 0x10))
|
|
mpu.regX = 0x03
|
|
memory[0x0010 + mpu.regX] = 0x10
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x0F, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_dec_zp_x_below_00_rolls_over_and_sets_negative_flag() {
|
|
// $0000 DEC 0x0010,X
|
|
writeMem(memory, 0x0000, listOf(0xD6, 0x10))
|
|
mpu.regX = 0x03
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_dec_zp_x_sets_zero_flag_when_decrementing_to_zero() {
|
|
// $0000 DEC 0x0010,X
|
|
writeMem(memory, 0x0000, listOf(0xD6, 0x10))
|
|
mpu.regX = 0x03
|
|
memory[0x0010 + mpu.regX] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// DEX
|
|
|
|
@Test
|
|
fun test_dex_decrements_x() {
|
|
mpu.regX = 0x10
|
|
// $0000 DEX
|
|
memory[0x0000] = 0xCA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x0F, mpu.regX)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_dex_below_00_rolls_over_and_sets_negative_flag() {
|
|
mpu.regX = 0x00
|
|
// $0000 DEX
|
|
memory[0x0000] = 0xCA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_dex_sets_zero_flag_when_decrementing_to_zero() {
|
|
mpu.regX = 0x01
|
|
// $0000 DEX
|
|
memory[0x0000] = 0xCA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// DEY
|
|
|
|
@Test
|
|
fun test_dey_decrements_y() {
|
|
mpu.regY = 0x10
|
|
// $0000 DEY
|
|
memory[0x0000] = 0x88
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x0F, mpu.regY)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_dey_below_00_rolls_over_and_sets_negative_flag() {
|
|
mpu.regY = 0x00
|
|
// $0000 DEY
|
|
memory[0x0000] = 0x88
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_dey_sets_zero_flag_when_decrementing_to_zero() {
|
|
mpu.regY = 0x01
|
|
// $0000 DEY
|
|
memory[0x0000] = 0x88
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
// EOR Absolute
|
|
|
|
@Test
|
|
fun test_eor_absolute_flips_bits_over_setting_z_flag() {
|
|
mpu.regA = 0xFF
|
|
writeMem(memory, 0x0000, listOf(0x4D, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_eor_absolute_flips_bits_over_setting_n_flag() {
|
|
mpu.regA = 0x00
|
|
writeMem(memory, 0x0000, listOf(0x4D, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// EOR Zero Page
|
|
|
|
@Test
|
|
fun test_eor_zp_flips_bits_over_setting_z_flag() {
|
|
mpu.regA = 0xFF
|
|
writeMem(memory, 0x0000, listOf(0x45, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0xFF, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_eor_zp_flips_bits_over_setting_n_flag() {
|
|
mpu.regA = 0x00
|
|
writeMem(memory, 0x0000, listOf(0x45, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(0xFF, memory[0x0010])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// EOR Immediate
|
|
|
|
@Test
|
|
fun test_eor_immediate_flips_bits_over_setting_z_flag() {
|
|
mpu.regA = 0xFF
|
|
writeMem(memory, 0x0000, listOf(0x49, 0xFF))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_eor_immediate_flips_bits_over_setting_n_flag() {
|
|
mpu.regA = 0x00
|
|
writeMem(memory, 0x0000, listOf(0x49, 0xFF))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// EOR Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_eor_abs_x_indexed_flips_bits_over_setting_z_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x5D, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_eor_abs_x_indexed_flips_bits_over_setting_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x5D, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// EOR Absolute, Y-Indexed
|
|
|
|
@Test
|
|
fun test_eor_abs_y_indexed_flips_bits_over_setting_z_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x59, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regY])
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_eor_abs_y_indexed_flips_bits_over_setting_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x59, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regY])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// EOR Indirect, Indexed (X)
|
|
|
|
@Test
|
|
fun test_eor_ind_indexed_x_flips_bits_over_setting_z_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x41, 0x10)) // => EOR listOf($0010,X)
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB)) // => Vector to $ABCD
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_eor_ind_indexed_x_flips_bits_over_setting_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x41, 0x10)) // => EOR listOf($0010,X)
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB)) // => Vector to $ABCD
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// EOR Indexed, Indirect (Y)
|
|
|
|
@Test
|
|
fun test_eor_indexed_ind_y_flips_bits_over_setting_z_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x51, 0x10)) // => EOR listOf($0010),Y
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) // => Vector to $ABCD
|
|
memory[0xABCD + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regY])
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_eor_indexed_ind_y_flips_bits_over_setting_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x51, 0x10)) // => EOR listOf($0010),Y
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) // => Vector to $ABCD
|
|
memory[0xABCD + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regY])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// EOR Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_eor_zp_x_indexed_flips_bits_over_setting_z_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x55, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0xFF, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_eor_zp_x_indexed_flips_bits_over_setting_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x55, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(0xFF, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// INC Absolute
|
|
|
|
@Test
|
|
fun test_inc_abs_increments_memory() {
|
|
writeMem(memory, 0x0000, listOf(0xEE, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x09
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x0A, memory[0xABCD])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inc_abs_increments_memory_rolls_over_and_sets_zero_flag() {
|
|
writeMem(memory, 0x0000, listOf(0xEE, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inc_abs_sets_negative_flag_when_incrementing_above_7F() {
|
|
writeMem(memory, 0x0000, listOf(0xEE, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, memory[0xABCD])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
// INC Zero Page
|
|
|
|
@Test
|
|
fun test_inc_zp_increments_memory() {
|
|
writeMem(memory, 0x0000, listOf(0xE6, 0x10))
|
|
memory[0x0010] = 0x09
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x0A, memory[0x0010])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inc_zp_increments_memory_rolls_over_and_sets_zero_flag() {
|
|
writeMem(memory, 0x0000, listOf(0xE6, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inc_zp_sets_negative_flag_when_incrementing_above_7F() {
|
|
writeMem(memory, 0x0000, listOf(0xE6, 0x10))
|
|
memory[0x0010] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, memory[0x0010])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
// INC Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_inc_abs_x_increments_memory() {
|
|
writeMem(memory, 0x0000, listOf(0xFE, 0xCD, 0xAB))
|
|
mpu.regX = 0x03
|
|
memory[0xABCD + mpu.regX] = 0x09
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x0A, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inc_abs_x_increments_memory_rolls_over_and_sets_zero_flag() {
|
|
writeMem(memory, 0x0000, listOf(0xFE, 0xCD, 0xAB))
|
|
mpu.regX = 0x03
|
|
memory[0xABCD + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inc_abs_x_sets_negative_flag_when_incrementing_above_7F() {
|
|
writeMem(memory, 0x0000, listOf(0xFE, 0xCD, 0xAB))
|
|
mpu.regX = 0x03
|
|
memory[0xABCD + mpu.regX] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
// INC Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_inc_zp_x_increments_memory() {
|
|
writeMem(memory, 0x0000, listOf(0xF6, 0x10))
|
|
mpu.regX = 0x03
|
|
memory[0x0010 + mpu.regX] = 0x09
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x0A, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inc_zp_x_increments_memory_rolls_over_and_sets_zero_flag() {
|
|
writeMem(memory, 0x0000, listOf(0xF6, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inc_zp_x_sets_negative_flag_when_incrementing_above_7F() {
|
|
writeMem(memory, 0x0000, listOf(0xF6, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
// INX
|
|
|
|
@Test
|
|
fun test_inx_increments_x() {
|
|
mpu.regX = 0x09
|
|
memory[0x0000] = 0xE8 // => INX
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x0A, mpu.regX)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_inx_above_FF_rolls_over_and_sets_zero_flag() {
|
|
mpu.regX = 0xFF
|
|
memory[0x0000] = 0xE8 // => INX
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_inx_sets_negative_flag_when_incrementing_above_7F() {
|
|
mpu.regX = 0x7f
|
|
memory[0x0000] = 0xE8 // => INX
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
// INY
|
|
|
|
@Test
|
|
fun test_iny_increments_y() {
|
|
mpu.regY = 0x09
|
|
memory[0x0000] = 0xC8 // => INY
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x0A, mpu.regY)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_iny_above_FF_rolls_over_and_sets_zero_flag() {
|
|
mpu.regY = 0xFF
|
|
memory[0x0000] = 0xC8 // => INY
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_iny_sets_negative_flag_when_incrementing_above_7F() {
|
|
mpu.regY = 0x7f
|
|
memory[0x0000] = 0xC8 // => INY
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
// JMP Absolute
|
|
|
|
@Test
|
|
fun test_jmp_abs_jumps_to_absolute_address() {
|
|
// $0000 JMP $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x4C, 0xCD, 0xAB))
|
|
mpu.step()
|
|
assertEquals(0xABCD, mpu.regPC)
|
|
}
|
|
|
|
// JMP Indirect
|
|
|
|
@Test
|
|
fun test_jmp_ind_jumps_to_indirect_address() {
|
|
// $0000 JMP ($ABCD)
|
|
writeMem(memory, 0x0000, listOf(0x6C, 0x00, 0x02))
|
|
writeMem(memory, 0x0200, listOf(0xCD, 0xAB))
|
|
mpu.step()
|
|
assertEquals(0xABCD, mpu.regPC)
|
|
}
|
|
|
|
// JSR
|
|
|
|
@Test
|
|
fun test_jsr_pushes_pc_plus_2_and_sets_pc() {
|
|
// $C000 JSR $FFD2
|
|
mpu.regSP = 0xFF
|
|
writeMem(memory, 0xC000, listOf(0x20, 0xD2, 0xFF))
|
|
mpu.regPC = 0xC000
|
|
mpu.step()
|
|
assertEquals(0xFFD2, mpu.regPC)
|
|
assertEquals(0xFD, mpu.regSP)
|
|
assertEquals(0xC0, memory[0x01FF]) // PCH
|
|
assertEquals(0x02, memory[0x01FE]) // PCL+2
|
|
}
|
|
|
|
// LDA Absolute
|
|
|
|
@Test
|
|
fun test_lda_absolute_loads_a_sets_n_flag() {
|
|
mpu.regA = 0x00
|
|
// $0000 LDA $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xAD, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_absolute_loads_a_sets_z_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 LDA $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xAD, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDA Zero Page
|
|
|
|
@Test
|
|
fun test_lda_zp_loads_a_sets_n_flag() {
|
|
mpu.regA = 0x00
|
|
// $0000 LDA $0010
|
|
writeMem(memory, 0x0000, listOf(0xA5, 0x10))
|
|
memory[0x0010] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_zp_loads_a_sets_z_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 LDA $0010
|
|
writeMem(memory, 0x0000, listOf(0xA5, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDA Immediate
|
|
|
|
@Test
|
|
fun test_lda_immediate_loads_a_sets_n_flag() {
|
|
mpu.regA = 0x00
|
|
// $0000 LDA #$80
|
|
writeMem(memory, 0x0000, listOf(0xA9, 0x80))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_immediate_loads_a_sets_z_flag() {
|
|
mpu.regA = 0xFF
|
|
// $0000 LDA #$00
|
|
writeMem(memory, 0x0000, listOf(0xA9, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDA Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_lda_abs_x_indexed_loads_a_sets_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 LDA $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0xBD, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_abs_x_indexed_loads_a_sets_z_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 LDA $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0xBD, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_abs_x_indexed_does_not_page_wrap() {
|
|
mpu.regA = 0
|
|
mpu.regX = 0xFF
|
|
// $0000 LDA $0080,X
|
|
writeMem(memory, 0x0000, listOf(0xBD, 0x80, 0x00))
|
|
memory[0x0080 + mpu.regX] = 0x42
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x42, mpu.regA)
|
|
}
|
|
|
|
// LDA Absolute, Y-Indexed
|
|
|
|
@Test
|
|
fun test_lda_abs_y_indexed_loads_a_sets_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 LDA $ABCD,Y
|
|
writeMem(memory, 0x0000, listOf(0xB9, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_abs_y_indexed_loads_a_sets_z_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 LDA $ABCD,Y
|
|
writeMem(memory, 0x0000, listOf(0xB9, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_abs_y_indexed_does_not_page_wrap() {
|
|
mpu.regA = 0
|
|
mpu.regY = 0xFF
|
|
// $0000 LDA $0080,X
|
|
writeMem(memory, 0x0000, listOf(0xB9, 0x80, 0x00))
|
|
memory[0x0080 + mpu.regY] = 0x42
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x42, mpu.regA)
|
|
}
|
|
|
|
// LDA Indirect, Indexed (X)
|
|
|
|
@Test
|
|
fun test_lda_ind_indexed_x_loads_a_sets_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 LDA ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xA1, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_ind_indexed_x_loads_a_sets_z_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 LDA ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xA1, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDA Indexed, Indirect (Y)
|
|
|
|
@Test
|
|
fun test_lda_indexed_ind_y_loads_a_sets_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 LDA ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xB1, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_indexed_ind_y_correct_index() {
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0xf3
|
|
// $0000 LDA ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xB1, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_indexed_ind_y_loads_a_sets_z_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 LDA ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xB1, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDA Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_lda_zp_x_indexed_loads_a_sets_n_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 LDA $10,X
|
|
writeMem(memory, 0x0000, listOf(0xB5, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_zp_x_indexed_correct_index() {
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0xf3
|
|
// $0000 LDA $10,X
|
|
writeMem(memory, 0x0000, listOf(0xB5, 0x10))
|
|
memory[(0x0010 + mpu.regX) and 255] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
}
|
|
|
|
@Test
|
|
fun test_lda_zp_x_indexed_loads_a_sets_z_flag() {
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 LDA $10,X
|
|
writeMem(memory, 0x0000, listOf(0xB5, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDX Absolute
|
|
|
|
@Test
|
|
fun test_ldx_absolute_loads_x_sets_n_flag() {
|
|
mpu.regX = 0x00
|
|
// $0000 LDX $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xAE, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldx_absolute_loads_x_sets_z_flag() {
|
|
mpu.regX = 0xFF
|
|
// $0000 LDX $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xAE, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDX Zero Page
|
|
|
|
@Test
|
|
fun test_ldx_zp_loads_x_sets_n_flag() {
|
|
mpu.regX = 0x00
|
|
// $0000 LDX $0010
|
|
writeMem(memory, 0x0000, listOf(0xA6, 0x10))
|
|
memory[0x0010] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldx_zp_loads_x_sets_z_flag() {
|
|
mpu.regX = 0xFF
|
|
// $0000 LDX $0010
|
|
writeMem(memory, 0x0000, listOf(0xA6, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDX Immediate
|
|
|
|
@Test
|
|
fun test_ldx_immediate_loads_x_sets_n_flag() {
|
|
mpu.regX = 0x00
|
|
// $0000 LDX #$80
|
|
writeMem(memory, 0x0000, listOf(0xA2, 0x80))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldx_immediate_loads_x_sets_z_flag() {
|
|
mpu.regX = 0xFF
|
|
// $0000 LDX #$00
|
|
writeMem(memory, 0x0000, listOf(0xA2, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDX Absolute, Y-Indexed
|
|
|
|
@Test
|
|
fun test_ldx_abs_y_indexed_loads_x_sets_n_flag() {
|
|
mpu.regX = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 LDX $ABCD,Y
|
|
writeMem(memory, 0x0000, listOf(0xBE, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldx_abs_y_indexed_loads_x_sets_z_flag() {
|
|
mpu.regX = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 LDX $ABCD,Y
|
|
writeMem(memory, 0x0000, listOf(0xBE, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDX Zero Page, Y-Indexed
|
|
|
|
@Test
|
|
fun test_ldx_zp_y_indexed_loads_x_sets_n_flag() {
|
|
mpu.regX = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 LDX $0010,Y
|
|
writeMem(memory, 0x0000, listOf(0xB6, 0x10))
|
|
memory[0x0010 + mpu.regY] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldx_zp_y_indexed_loads_x_sets_z_flag() {
|
|
mpu.regX = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 LDX $0010,Y
|
|
writeMem(memory, 0x0000, listOf(0xB6, 0x10))
|
|
memory[0x0010 + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDY Absolute
|
|
|
|
@Test
|
|
fun test_ldy_absolute_loads_y_sets_n_flag() {
|
|
mpu.regY = 0x00
|
|
// $0000 LDY $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xAC, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldy_absolute_loads_y_sets_z_flag() {
|
|
mpu.regY = 0xFF
|
|
// $0000 LDY $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xAC, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDY Zero Page
|
|
|
|
@Test
|
|
fun test_ldy_zp_loads_y_sets_n_flag() {
|
|
mpu.regY = 0x00
|
|
// $0000 LDY $0010
|
|
writeMem(memory, 0x0000, listOf(0xA4, 0x10))
|
|
memory[0x0010] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldy_zp_loads_y_sets_z_flag() {
|
|
mpu.regY = 0xFF
|
|
// $0000 LDY $0010
|
|
writeMem(memory, 0x0000, listOf(0xA4, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDY Immediate
|
|
|
|
@Test
|
|
fun test_ldy_immediate_loads_y_sets_n_flag() {
|
|
mpu.regY = 0x00
|
|
// $0000 LDY #$80
|
|
writeMem(memory, 0x0000, listOf(0xA0, 0x80))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldy_immediate_loads_y_sets_z_flag() {
|
|
mpu.regY = 0xFF
|
|
// $0000 LDY #$00
|
|
writeMem(memory, 0x0000, listOf(0xA0, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDY Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_ldy_abs_x_indexed_loads_x_sets_n_flag() {
|
|
mpu.regY = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 LDY $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0xBC, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldy_abs_x_indexed_loads_x_sets_z_flag() {
|
|
mpu.regY = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 LDY $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0xBC, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LDY Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_ldy_zp_x_indexed_loads_x_sets_n_flag() {
|
|
mpu.regY = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 LDY $0010,X
|
|
writeMem(memory, 0x0000, listOf(0xB4, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ldy_zp_x_indexed_loads_x_sets_z_flag() {
|
|
mpu.regY = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 LDY $0010,X
|
|
writeMem(memory, 0x0000, listOf(0xB4, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LSR Accumulator
|
|
|
|
@Test
|
|
fun test_lsr_accumulator_rotates_in_zero_not_carry() {
|
|
mpu.regP.C = true
|
|
// $0000 LSR A
|
|
memory[0x0000] = (0x4A)
|
|
mpu.regA = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_accumulator_sets_carry_and_zero_flags_after_rotation() {
|
|
mpu.regP.C = false
|
|
// $0000 LSR A
|
|
memory[0x0000] = (0x4A)
|
|
mpu.regA = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_accumulator_rotates_bits_right() {
|
|
mpu.regP.C = true
|
|
// $0000 LSR A
|
|
memory[0x0000] = (0x4A)
|
|
mpu.regA = 0x04
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x02, mpu.regA)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LSR Absolute
|
|
|
|
@Test
|
|
fun test_lsr_absolute_rotates_in_zero_not_carry() {
|
|
mpu.regP.C = true
|
|
// $0000 LSR $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x4E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_absolute_sets_carry_and_zero_flags_after_rotation() {
|
|
mpu.regP.C = false
|
|
// $0000 LSR $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x4E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_absolute_rotates_bits_right() {
|
|
mpu.regP.C = true
|
|
// $0000 LSR $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x4E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x04
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x02, memory[0xABCD])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LSR Zero Page
|
|
|
|
@Test
|
|
fun test_lsr_zp_rotates_in_zero_not_carry() {
|
|
mpu.regP.C = true
|
|
// $0000 LSR $0010
|
|
writeMem(memory, 0x0000, listOf(0x46, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_zp_sets_carry_and_zero_flags_after_rotation() {
|
|
mpu.regP.C = false
|
|
// $0000 LSR $0010
|
|
writeMem(memory, 0x0000, listOf(0x46, 0x10))
|
|
memory[0x0010] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_zp_rotates_bits_right() {
|
|
mpu.regP.C = true
|
|
// $0000 LSR $0010
|
|
writeMem(memory, 0x0000, listOf(0x46, 0x10))
|
|
memory[0x0010] = 0x04
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x02, memory[0x0010])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LSR Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_lsr_abs_x_indexed_rotates_in_zero_not_carry() {
|
|
mpu.regP.C = true
|
|
mpu.regX = 0x03
|
|
// $0000 LSR $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x5E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_abs_x_indexed_sets_c_and_z_flags_after_rotation() {
|
|
mpu.regP.C = false
|
|
mpu.regX = 0x03
|
|
// $0000 LSR $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x5E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_abs_x_indexed_rotates_bits_right() {
|
|
mpu.regP.C = true
|
|
// $0000 LSR $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x5E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x04
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x02, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// LSR Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_lsr_zp_x_indexed_rotates_in_zero_not_carry() {
|
|
mpu.regP.C = true
|
|
mpu.regX = 0x03
|
|
// $0000 LSR $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x56, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_zp_x_indexed_sets_carry_and_zero_flags_after_rotation() {
|
|
mpu.regP.C = false
|
|
mpu.regX = 0x03
|
|
// $0000 LSR $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x56, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_lsr_zp_x_indexed_rotates_bits_right() {
|
|
mpu.regP.C = true
|
|
mpu.regX = 0x03
|
|
// $0000 LSR $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x56, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x04
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x02, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.C)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
// NOP
|
|
|
|
@Test
|
|
fun test_nop_does_nothing() {
|
|
// $0000 NOP
|
|
memory[0x0000] = 0xEA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
}
|
|
|
|
// ORA Absolute
|
|
|
|
@Test
|
|
fun test_ora_absolute_zeroes_or_zeros_sets_z_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
// $0000 ORA $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x0D, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ora_absolute_turns_bits_on_sets_n_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x03
|
|
// $0000 ORA $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x0D, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x82
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x83, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ORA Zero Page
|
|
|
|
@Test
|
|
fun test_ora_zp_zeroes_or_zeros_sets_z_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
// $0000 ORA $0010
|
|
writeMem(memory, 0x0000, listOf(0x05, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ora_zp_turns_bits_on_sets_n_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x03
|
|
// $0000 ORA $0010
|
|
writeMem(memory, 0x0000, listOf(0x05, 0x10))
|
|
memory[0x0010] = 0x82
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x83, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ORA Immediate
|
|
|
|
@Test
|
|
fun test_ora_immediate_zeroes_or_zeros_sets_z_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
// $0000 ORA #$00
|
|
writeMem(memory, 0x0000, listOf(0x09, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ora_immediate_turns_bits_on_sets_n_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x03
|
|
// $0000 ORA #$82
|
|
writeMem(memory, 0x0000, listOf(0x09, 0x82))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x83, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ORA Absolute, X
|
|
|
|
@Test
|
|
fun test_ora_abs_x_indexed_zeroes_or_zeros_sets_z_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 ORA $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x1D, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ora_abs_x_indexed_turns_bits_on_sets_n_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x03
|
|
mpu.regX = 0x03
|
|
// $0000 ORA $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x1D, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x82
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x83, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ORA Absolute, Y
|
|
|
|
@Test
|
|
fun test_ora_abs_y_indexed_zeroes_or_zeros_sets_z_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 ORA $ABCD,Y
|
|
writeMem(memory, 0x0000, listOf(0x19, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ora_abs_y_indexed_turns_bits_on_sets_n_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x03
|
|
mpu.regY = 0x03
|
|
// $0000 ORA $ABCD,Y
|
|
writeMem(memory, 0x0000, listOf(0x19, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x82
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x83, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ORA Indirect, Indexed (X)
|
|
|
|
@Test
|
|
fun test_ora_ind_indexed_x_zeroes_or_zeros_sets_z_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 ORA ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x01, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ora_ind_indexed_x_turns_bits_on_sets_n_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x03
|
|
mpu.regX = 0x03
|
|
// $0000 ORA ($0010,X)
|
|
// $0013 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x01, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xCD, 0xAB))
|
|
memory[0xABCD] = 0x82
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x83, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ORA Indexed, Indirect (Y)
|
|
|
|
@Test
|
|
fun test_ora_indexed_ind_y_zeroes_or_zeros_sets_z_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 ORA ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x11, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ora_indexed_ind_y_turns_bits_on_sets_n_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x03
|
|
mpu.regY = 0x03
|
|
// $0000 ORA ($0010),Y
|
|
// $0010 Vector to $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x11, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x82
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x83, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// ORA Zero Page, X
|
|
|
|
@Test
|
|
fun test_ora_zp_x_indexed_zeroes_or_zeros_sets_z_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 ORA $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x15, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_ora_zp_x_indexed_turns_bits_on_sets_n_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x03
|
|
mpu.regX = 0x03
|
|
// $0000 ORA $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x15, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x82
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x83, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// PHA
|
|
|
|
@Test
|
|
fun test_pha_pushes_a_and_updates_sp() {
|
|
mpu.regA = 0xAB
|
|
// $0000 PHA
|
|
memory[0x0000] = 0x48
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAB, mpu.regA)
|
|
assertEquals(0xFC, mpu.regSP)
|
|
assertEquals(0xAB, memory[0x01FD])
|
|
}
|
|
|
|
// PHP
|
|
|
|
@Test
|
|
fun test_php_pushes_processor_status_and_updates_sp() {
|
|
for (flags in 0 until 0x100) {
|
|
mpu.reset()
|
|
mpu.regP.fromInt(flags or fBREAK or fUNUSED)
|
|
// $0000 PHP
|
|
memory[0x0000] = 0x08
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xFC, mpu.regSP)
|
|
assertEquals((flags or fBREAK or fUNUSED), memory[0x1FD].toInt())
|
|
}
|
|
}
|
|
|
|
// PLA
|
|
|
|
@Test
|
|
fun test_pla_pulls_top_byte_from_stack_into_a_and_updates_sp() {
|
|
// $0000 PLA
|
|
memory[0x0000] = 0x68
|
|
memory[0x01FF] = 0xAB
|
|
mpu.regSP = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAB, mpu.regA)
|
|
assertEquals(0xFF, mpu.regSP)
|
|
}
|
|
|
|
// PLP
|
|
|
|
@Test
|
|
fun test_plp_pulls_top_byte_from_stack_into_flags_and_updates_sp() {
|
|
mpu.regP.fromInt(0)
|
|
memory[0x01FF] = 0xBA // must have BREAK and UNUSED set
|
|
memory[0x0000] = 0x28 // PLP
|
|
mpu.regSP = 0xFE
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAA, mpu.regP.asInt()) // BREAK cleared
|
|
assertEquals(0xFF, mpu.regSP)
|
|
}
|
|
|
|
// ROL Accumulator
|
|
|
|
@Test
|
|
fun test_rol_accumulator_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regP.C = false
|
|
memory[0x0000] = 0x2A // ROL A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_accumulator_80_and_carry_zero_sets_z_flag() {
|
|
mpu.regA = 0x80
|
|
mpu.regP.C = false
|
|
mpu.regP.Z = false
|
|
// $0000 ROL A
|
|
memory[0x0000] = 0x2A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_accumulator_zero_and_carry_one_clears_z_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regP.C = true
|
|
// $0000 ROL A
|
|
memory[0x0000] = 0x2A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x01, mpu.regA)
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_accumulator_sets_n_flag() {
|
|
mpu.regA = 0x40
|
|
mpu.regP.C = true
|
|
// $0000 ROL A
|
|
memory[0x0000] = 0x2A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x81, mpu.regA)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_accumulator_shifts_out_zero() {
|
|
mpu.regA = 0x7F
|
|
mpu.regP.C = false
|
|
// $0000 ROL A
|
|
memory[0x0000] = 0x2A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xFE, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_accumulator_shifts_out_one() {
|
|
mpu.regA = 0xFF
|
|
mpu.regP.C = false
|
|
// $0000 ROL A
|
|
memory[0x0000] = 0x2A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xFE, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROL Absolute
|
|
|
|
@Test
|
|
fun test_rol_absolute_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
// $0000 ROL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_absolute_80_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
mpu.regP.Z = false
|
|
// $0000 ROL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_absolute_zero_and_carry_one_clears_z_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regP.C = true
|
|
// $0000 ROL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x01, memory[0xABCD])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_absolute_sets_n_flag() {
|
|
mpu.regP.C = true
|
|
// $0000 ROL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x81, memory[0xABCD])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_absolute_shifts_out_zero() {
|
|
mpu.regP.C = false
|
|
// $0000 ROL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFE, memory[0xABCD])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_absolute_shifts_out_one() {
|
|
mpu.regP.C = false
|
|
// $0000 ROL $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFE, memory[0xABCD])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROL Zero Page
|
|
|
|
@Test
|
|
fun test_rol_zp_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
// $0000 ROL $0010
|
|
writeMem(memory, 0x0000, listOf(0x26, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_80_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
mpu.regP.Z = false
|
|
// $0000 ROL $0010
|
|
writeMem(memory, 0x0000, listOf(0x26, 0x10))
|
|
memory[0x0010] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_zero_and_carry_one_clears_z_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regP.C = true
|
|
// $0000 ROL $0010
|
|
writeMem(memory, 0x0000, listOf(0x26, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, memory[0x0010])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_sets_n_flag() {
|
|
mpu.regP.C = true
|
|
// $0000 ROL $0010
|
|
writeMem(memory, 0x0000, listOf(0x26, 0x10))
|
|
memory[0x0010] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x81, memory[0x0010])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_shifts_out_zero() {
|
|
mpu.regP.C = false
|
|
// $0000 ROL $0010
|
|
writeMem(memory, 0x0000, listOf(0x26, 0x10))
|
|
memory[0x0010] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFE, memory[0x0010])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_shifts_out_one() {
|
|
mpu.regP.C = false
|
|
// $0000 ROL $0010
|
|
writeMem(memory, 0x0000, listOf(0x26, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFE, memory[0x0010])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROL Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_rol_abs_x_indexed_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
mpu.regX = 0x03
|
|
// $0000 ROL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_abs_x_indexed_80_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
mpu.regP.Z = false
|
|
mpu.regX = 0x03
|
|
// $0000 ROL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_abs_x_indexed_zero_and_carry_one_clears_z_flag() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x01, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_abs_x_indexed_sets_n_flag() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x81, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_abs_x_indexed_shifts_out_zero() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = false
|
|
// $0000 ROL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFE, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_abs_x_indexed_shifts_out_one() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = false
|
|
// $0000 ROL $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFE, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROL Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_rol_zp_x_indexed_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
mpu.regX = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x36, 0x10))
|
|
// $0000 ROL $0010,X
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_x_indexed_80_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
mpu.regP.Z = false
|
|
mpu.regX = 0x03
|
|
writeMem(memory, 0x0000, listOf(0x36, 0x10))
|
|
// $0000 ROL $0010,X
|
|
memory[0x0010 + mpu.regX] = 0x80
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_x_indexed_zero_and_carry_one_clears_z_flag() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
writeMem(memory, 0x0000, listOf(0x36, 0x10))
|
|
// $0000 ROL $0010,X
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x01, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_x_indexed_sets_n_flag() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROL $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x36, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x40
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x81, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_x_indexed_shifts_out_zero() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = false
|
|
// $0000 ROL $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x36, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x7F
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFE, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_rol_zp_x_indexed_shifts_out_one() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = false
|
|
// $0000 ROL $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x36, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFE, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROR Accumulator
|
|
|
|
@Test
|
|
fun test_ror_accumulator_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regA = 0x00
|
|
mpu.regP.C = false
|
|
// $0000 ROR A
|
|
memory[0x0000] = 0x6A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_accumulator_zero_and_carry_one_rotates_in_sets_n_flags() {
|
|
mpu.regA = 0x00
|
|
mpu.regP.C = true
|
|
// $0000 ROR A
|
|
memory[0x0000] = 0x6A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_accumulator_shifts_out_zero() {
|
|
mpu.regA = 0x02
|
|
mpu.regP.C = true
|
|
// $0000 ROR A
|
|
memory[0x0000] = 0x6A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x81, mpu.regA)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_accumulator_shifts_out_one() {
|
|
mpu.regA = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROR A
|
|
memory[0x0000] = 0x6A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x81, mpu.regA)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROR Absolute
|
|
|
|
@Test
|
|
fun test_ror_absolute_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
// $0000 ROR $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x6E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_absolute_zero_and_carry_one_rotates_in_sets_n_flags() {
|
|
mpu.regP.C = true
|
|
// $0000 ROR $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x6E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, memory[0xABCD])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_absolute_shifts_out_zero() {
|
|
mpu.regP.C = true
|
|
// $0000 ROR $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x6E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x81, memory[0xABCD])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_absolute_shifts_out_one() {
|
|
mpu.regP.C = true
|
|
// $0000 ROR $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x6E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x03
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x81, memory[0xABCD])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROR Zero Page
|
|
|
|
@Test
|
|
fun test_ror_zp_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regP.C = false
|
|
// $0000 ROR $0010
|
|
writeMem(memory, 0x0000, listOf(0x66, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_zp_zero_and_carry_one_rotates_in_sets_n_flags() {
|
|
mpu.regP.C = true
|
|
// $0000 ROR $0010
|
|
writeMem(memory, 0x0000, listOf(0x66, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, memory[0x0010])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_zp_zero_absolute_shifts_out_zero() {
|
|
mpu.regP.C = true
|
|
// $0000 ROR $0010
|
|
writeMem(memory, 0x0000, listOf(0x66, 0x10))
|
|
memory[0x0010] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x81, memory[0x0010])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_zp_shifts_out_one() {
|
|
mpu.regP.C = true
|
|
// $0000 ROR $0010
|
|
writeMem(memory, 0x0000, listOf(0x66, 0x10))
|
|
memory[0x0010] = 0x03
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x81, memory[0x0010])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROR Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_ror_abs_x_indexed_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = false
|
|
// $0000 ROR $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x7E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_abs_x_indexed_z_and_c_1_rotates_in_sets_n_flags() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROR $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x7E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x80, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_abs_x_indexed_shifts_out_zero() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROR $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x7E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x81, memory[0xABCD + mpu.regX])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_abs_x_indexed_shifts_out_one() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROR $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x7E, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x03
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x81, memory[0xABCD + mpu.regX])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// ROR Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_ror_zp_x_indexed_zero_and_carry_zero_sets_z_flag() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = false
|
|
// $0000 ROR $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x76, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.Z)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_zp_x_indexed_zero_and_carry_one_rotates_in_sets_n_flags() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROR $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x76, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x80, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_zp_x_indexed_zero_absolute_shifts_out_zero() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROR $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x76, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x81, memory[0x0010 + mpu.regX])
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_ror_zp_x_indexed_shifts_out_one() {
|
|
mpu.regX = 0x03
|
|
mpu.regP.C = true
|
|
// $0000 ROR $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x76, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x03
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x81, memory[0x0010 + mpu.regX])
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// RTI
|
|
|
|
@Test
|
|
fun test_rti_restores_status_and_pc_and_updates_sp() {
|
|
// $0000 RTI
|
|
memory[0x0000] = 0x40
|
|
writeMem(memory, 0x01FD, listOf(0xFC, 0x03, 0xC0)) // Status, PCL, PCH
|
|
mpu.regSP = 0xFC
|
|
mpu.step()
|
|
assertEquals(0xFF, mpu.regSP)
|
|
assertEquals(0xEC, mpu.regP.asInt()) // BREAK flag cleared
|
|
assertEquals(0xC003, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
@Disabled("this test is invalid")
|
|
fun test_rti_forces_break_and_unused_flags_high() {
|
|
assertEquals(0b00100000, mpu.regP.asInt())
|
|
memory[0x0000] = 0x40 // RTI
|
|
writeMem(memory, 0x01FD, listOf(0x00, 0x03, 0xC0)) // Status, PCL, PCH
|
|
mpu.regSP = 0xFC
|
|
mpu.step()
|
|
assertEquals(0b00110000, mpu.regP.asInt())
|
|
}
|
|
|
|
// RTS
|
|
|
|
@Test
|
|
fun test_rts_restores_pc_and_increments_then_updates_sp() {
|
|
// $0000 RTS
|
|
memory[0x0000] = 0x60
|
|
writeMem(memory, 0x01FE, listOf(0x03, 0xC0)) // PCL, PCH
|
|
mpu.regPC = 0x0000
|
|
mpu.regSP = 0xFD
|
|
mpu.step()
|
|
assertEquals(0xC004, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regSP)
|
|
}
|
|
|
|
@Test
|
|
fun test_rts_wraps_around_top_of_memory() {
|
|
// $1000 RTS
|
|
memory[0x1000] = 0x60
|
|
writeMem(memory, 0x01FE, listOf(0xFF, 0xFF)) // PCL, PCH
|
|
mpu.regPC = 0x1000
|
|
mpu.regSP = 0xFD
|
|
mpu.step()
|
|
assertEquals(0x0000, mpu.regPC)
|
|
assertEquals(0xFF, mpu.regSP)
|
|
}
|
|
|
|
// SBC Absolute
|
|
|
|
@Test
|
|
fun test_sbc_abs_all_zeros_and_no_borrow_is_zero() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x00
|
|
// $0000 SBC $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xED, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_downto_zero_no_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xED, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_downto_zero_with_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xED, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_downto_four_with_borrow_clears_z_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x07
|
|
// $0000 SBC $ABCD
|
|
writeMem(memory, 0x0000, listOf(0xED, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x04, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// SBC Zero Page
|
|
|
|
@Test
|
|
fun test_sbc_zp_all_zeros_and_no_borrow_is_zero() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x00
|
|
// $0000 SBC $10
|
|
writeMem(memory, 0x0000, listOf(0xE5, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_zp_downto_zero_no_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $10
|
|
writeMem(memory, 0x0000, listOf(0xE5, 0x10))
|
|
memory[0x0010] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_zp_downto_zero_with_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x01
|
|
// => SBC $10
|
|
writeMem(memory, 0x0000, listOf(0xE5, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_zp_downto_four_with_borrow_clears_z_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x07
|
|
// => SBC $10
|
|
writeMem(memory, 0x0000, listOf(0xE5, 0x10))
|
|
memory[0x0010] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x04, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// SBC Immediate
|
|
|
|
@Test
|
|
fun test_sbc_imm_all_zeros_and_no_borrow_is_zero() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x00
|
|
// $0000 SBC #$00
|
|
writeMem(memory, 0x0000, listOf(0xE9, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_imm_downto_zero_no_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x01
|
|
// $0000 SBC #$01
|
|
writeMem(memory, 0x0000, listOf(0xE9, 0x01))
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_imm_downto_zero_with_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x01
|
|
// $0000 SBC #$00
|
|
writeMem(memory, 0x0000, listOf(0xE9, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_imm_downto_four_with_borrow_clears_z_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x07
|
|
// $0000 SBC #$02
|
|
writeMem(memory, 0x0000, listOf(0xE9, 0x02))
|
|
mpu.step()
|
|
assertEquals(0x04, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_bcd_on_immediate_0a_minus_00_carry_set() {
|
|
mpu.regP.D = true
|
|
mpu.regP.C = true
|
|
mpu.regA = 0x0a
|
|
// $0000 SBC #$00
|
|
writeMem(memory, 0x0000, listOf(0xe9, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x0a, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.V)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_bcd_on_immediate_9a_minus_00_carry_set() {
|
|
mpu.regP.D = true
|
|
mpu.regP.C = true
|
|
mpu.regA = 0x9a
|
|
// $0000 SBC #$00
|
|
writeMem(memory, 0x0000, listOf(0xe9, 0x00))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x9a, mpu.regA)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.V)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_bcd_on_immediate_00_minus_01_carry_set() {
|
|
mpu.regP.D = true
|
|
mpu.regP.V = true
|
|
mpu.regP.Z = true
|
|
mpu.regP.C = true
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x00
|
|
// => $0000 SBC #$00
|
|
writeMem(memory, 0x0000, listOf(0xe9, 0x01))
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x99, mpu.regA)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.N)
|
|
assertFalse(mpu.regP.V)
|
|
assertFalse(mpu.regP.C)
|
|
}
|
|
|
|
// SBC Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_sbc_abs_x_all_zeros_and_no_borrow_is_zero() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x00
|
|
// $0000 SBC $FEE0,X
|
|
writeMem(memory, 0x0000, listOf(0xFD, 0xE0, 0xFE))
|
|
mpu.regX = 0x0D
|
|
memory[0xFEED] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_x_downto_zero_no_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $FEE0,X
|
|
writeMem(memory, 0x0000, listOf(0xFD, 0xE0, 0xFE))
|
|
mpu.regX = 0x0D
|
|
memory[0xFEED] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_x_downto_zero_with_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $FEE0,X
|
|
writeMem(memory, 0x0000, listOf(0xFD, 0xE0, 0xFE))
|
|
mpu.regX = 0x0D
|
|
memory[0xFEED] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_x_downto_four_with_borrow_clears_z_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x07
|
|
// $0000 SBC $FEE0,X
|
|
writeMem(memory, 0x0000, listOf(0xFD, 0xE0, 0xFE))
|
|
mpu.regX = 0x0D
|
|
memory[0xFEED] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x04, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// SBC Absolute, Y-Indexed
|
|
|
|
@Test
|
|
fun test_sbc_abs_y_all_zeros_and_no_borrow_is_zero() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x00
|
|
// $0000 SBC $FEE0,Y
|
|
writeMem(memory, 0x0000, listOf(0xF9, 0xE0, 0xFE))
|
|
mpu.regY = 0x0D
|
|
memory[0xFEED] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_y_downto_zero_no_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $FEE0,Y
|
|
writeMem(memory, 0x0000, listOf(0xF9, 0xE0, 0xFE))
|
|
mpu.regY = 0x0D
|
|
memory[0xFEED] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_y_downto_zero_with_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $FEE0,Y
|
|
writeMem(memory, 0x0000, listOf(0xF9, 0xE0, 0xFE))
|
|
mpu.regY = 0x0D
|
|
memory[0xFEED] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_abs_y_downto_four_with_borrow_clears_z_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x07
|
|
// $0000 SBC $FEE0,Y
|
|
writeMem(memory, 0x0000, listOf(0xF9, 0xE0, 0xFE))
|
|
mpu.regY = 0x0D
|
|
memory[0xFEED] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x04, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// SBC Indirect, Indexed (X)
|
|
|
|
@Test
|
|
fun test_sbc_ind_x_all_zeros_and_no_borrow_is_zero() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x00
|
|
// $0000 SBC ($10,X)
|
|
// $0013 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0xE1, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xED, 0xFE))
|
|
mpu.regX = 0x03
|
|
memory[0xFEED] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_ind_x_downto_zero_no_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x01
|
|
// $0000 SBC ($10,X)
|
|
// $0013 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0xE1, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xED, 0xFE))
|
|
mpu.regX = 0x03
|
|
memory[0xFEED] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_ind_x_downto_zero_with_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x01
|
|
// $0000 SBC ($10,X)
|
|
// $0013 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0xE1, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xED, 0xFE))
|
|
mpu.regX = 0x03
|
|
memory[0xFEED] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_ind_x_downto_four_with_borrow_clears_z_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x07
|
|
// $0000 SBC ($10,X)
|
|
// $0013 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0xE1, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xED, 0xFE))
|
|
mpu.regX = 0x03
|
|
memory[0xFEED] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x04, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// SBC Indexed, Indirect (Y)
|
|
|
|
@Test
|
|
fun test_sbc_ind_y_all_zeros_and_no_borrow_is_zero() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 SBC ($10),Y
|
|
// $0010 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0xF1, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xED, 0xFE))
|
|
memory[0xFEED + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_ind_y_downto_zero_no_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x01
|
|
// $0000 SBC ($10),Y
|
|
// $0010 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0xF1, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xED, 0xFE))
|
|
memory[0xFEED + mpu.regY] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_ind_y_downto_zero_with_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x01
|
|
// $0000 SBC ($10),Y
|
|
// $0010 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0xF1, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xED, 0xFE))
|
|
memory[0xFEED + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_ind_y_downto_four_with_borrow_clears_z_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x07
|
|
// $0000 SBC ($10),Y
|
|
// $0010 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0xF1, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xED, 0xFE))
|
|
memory[0xFEED + mpu.regY] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x04, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// SBC Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_sbc_zp_x_all_zeros_and_no_borrow_is_zero() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x00
|
|
// $0000 SBC $10,X
|
|
writeMem(memory, 0x0000, listOf(0xF5, 0x10))
|
|
mpu.regX = 0x0D
|
|
memory[0x001D] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_zp_x_downto_zero_no_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = true // borrow = 0
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $10,X
|
|
writeMem(memory, 0x0000, listOf(0xF5, 0x10))
|
|
mpu.regX = 0x0D
|
|
memory[0x001D] = 0x01
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_zp_x_downto_zero_with_borrow_sets_z_clears_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x01
|
|
// $0000 SBC $10,X
|
|
writeMem(memory, 0x0000, listOf(0xF5, 0x10))
|
|
mpu.regX = 0x0D
|
|
memory[0x001D] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertTrue(mpu.regP.C)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
@Test
|
|
fun test_sbc_zp_x_downto_four_with_borrow_clears_z_n() {
|
|
mpu.regP.D = false
|
|
mpu.regP.C = false // borrow = 1
|
|
mpu.regA = 0x07
|
|
// $0000 SBC $10,X
|
|
writeMem(memory, 0x0000, listOf(0xF5, 0x10))
|
|
mpu.regX = 0x0D
|
|
memory[0x001D] = 0x02
|
|
mpu.step()
|
|
assertEquals(0x04, mpu.regA)
|
|
assertFalse(mpu.regP.N)
|
|
assertFalse(mpu.regP.Z)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// SEC
|
|
|
|
@Test
|
|
fun test_sec_sets_carry_flag() {
|
|
mpu.regP.C = false
|
|
// $0000 SEC
|
|
memory[0x0000] = 0x038
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertTrue(mpu.regP.C)
|
|
}
|
|
|
|
// SED
|
|
|
|
@Test
|
|
fun test_sed_sets_decimal_mode_flag() {
|
|
mpu.regP.D = false
|
|
// $0000 SED
|
|
memory[0x0000] = 0xF8
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertTrue(mpu.regP.D)
|
|
}
|
|
|
|
// SEI
|
|
|
|
@Test
|
|
fun test_sei_sets_interrupt_disable_flag() {
|
|
mpu.regP.I = false
|
|
// $0000 SEI
|
|
memory[0x0000] = 0x78
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertTrue(mpu.regP.I)
|
|
}
|
|
|
|
// STA Absolute
|
|
|
|
@Test
|
|
fun test_sta_absolute_stores_a_leaves_a_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0xFF
|
|
// $0000 STA $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x8D, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xABCD])
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sta_absolute_stores_a_leaves_a_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0x00
|
|
// $0000 STA $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x8D, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STA Zero Page
|
|
|
|
@Test
|
|
fun test_sta_zp_stores_a_leaves_a_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0xFF
|
|
// $0000 STA $0010
|
|
writeMem(memory, 0x0000, listOf(0x85, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0x0010])
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sta_zp_stores_a_leaves_a_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0x00
|
|
// $0000 STA $0010
|
|
writeMem(memory, 0x0000, listOf(0x85, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STA Absolute, X-Indexed
|
|
|
|
@Test
|
|
fun test_sta_abs_x_indexed_stores_a_leaves_a_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 STA $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x9D, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regX])
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sta_abs_x_indexed_stores_a_leaves_a_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 STA $ABCD,X
|
|
writeMem(memory, 0x0000, listOf(0x9D, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regX])
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STA Absolute, Y-Indexed
|
|
|
|
@Test
|
|
fun test_sta_abs_y_indexed_stores_a_leaves_a_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 STA $ABCD,Y
|
|
writeMem(memory, 0x0000, listOf(0x99, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xABCD + mpu.regY])
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sta_abs_y_indexed_stores_a_leaves_a_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 STA $ABCD,Y
|
|
writeMem(memory, 0x0000, listOf(0x99, 0xCD, 0xAB))
|
|
memory[0xABCD + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD + mpu.regY])
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STA Indirect, Indexed (X)
|
|
|
|
@Test
|
|
fun test_sta_ind_indexed_x_stores_a_leaves_a_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 STA ($0010,X)
|
|
// $0013 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0x81, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xED, 0xFE))
|
|
memory[0xFEED] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xFEED])
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sta_ind_indexed_x_stores_a_leaves_a_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 STA ($0010,X)
|
|
// $0013 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0x81, 0x10))
|
|
writeMem(memory, 0x0013, listOf(0xED, 0xFE))
|
|
memory[0xFEED] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0xFEED])
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STA Indexed, Indirect (Y)
|
|
|
|
@Test
|
|
fun test_sta_indexed_ind_y_stores_a_leaves_a_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 STA ($0010),Y
|
|
// $0010 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0x91, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xED, 0xFE))
|
|
memory[0xFEED + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xFEED + mpu.regY])
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sta_indexed_ind_y_stores_a_leaves_a_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 STA ($0010),Y
|
|
// $0010 Vector to $FEED
|
|
writeMem(memory, 0x0000, listOf(0x91, 0x10))
|
|
writeMem(memory, 0x0010, listOf(0xED, 0xFE))
|
|
memory[0xFEED + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0xFEED + mpu.regY])
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STA Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_sta_zp_x_indexed_stores_a_leaves_a_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 STA $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x95, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0x0010 + mpu.regX])
|
|
assertEquals(0xFF, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sta_zp_x_indexed_stores_a_leaves_a_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 STA $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x95, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STX Absolute
|
|
|
|
@Test
|
|
fun test_stx_absolute_stores_x_leaves_x_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regX = 0xFF
|
|
// $0000 STX $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x8E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xABCD])
|
|
assertEquals(0xFF, mpu.regX)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_stx_absolute_stores_x_leaves_x_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regX = 0x00
|
|
// $0000 STX $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x8E, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertEquals(0x00, mpu.regX)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STX Zero Page
|
|
|
|
@Test
|
|
fun test_stx_zp_stores_x_leaves_x_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regX = 0xFF
|
|
// $0000 STX $0010
|
|
writeMem(memory, 0x0000, listOf(0x86, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0x0010])
|
|
assertEquals(0xFF, mpu.regX)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_stx_zp_stores_x_leaves_x_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regX = 0x00
|
|
// $0000 STX $0010
|
|
writeMem(memory, 0x0000, listOf(0x86, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertEquals(0x00, mpu.regX)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STX Zero Page, Y-Indexed
|
|
|
|
@Test
|
|
fun test_stx_zp_y_indexed_stores_x_leaves_x_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regX = 0xFF
|
|
mpu.regY = 0x03
|
|
// $0000 STX $0010,Y
|
|
writeMem(memory, 0x0000, listOf(0x96, 0x10))
|
|
memory[0x0010 + mpu.regY] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0x0010 + mpu.regY])
|
|
assertEquals(0xFF, mpu.regX)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_stx_zp_y_indexed_stores_x_leaves_x_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regX = 0x00
|
|
mpu.regY = 0x03
|
|
// $0000 STX $0010,Y
|
|
writeMem(memory, 0x0000, listOf(0x96, 0x10))
|
|
memory[0x0010 + mpu.regY] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regY])
|
|
assertEquals(0x00, mpu.regX)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STY Absolute
|
|
|
|
@Test
|
|
fun test_sty_absolute_stores_y_leaves_y_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regY = 0xFF
|
|
// $0000 STY $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x8C, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0xFF, memory[0xABCD])
|
|
assertEquals(0xFF, mpu.regY)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sty_absolute_stores_y_leaves_y_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regY = 0x00
|
|
// $0000 STY $ABCD
|
|
writeMem(memory, 0x0000, listOf(0x8C, 0xCD, 0xAB))
|
|
memory[0xABCD] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0003, mpu.regPC)
|
|
assertEquals(0x00, memory[0xABCD])
|
|
assertEquals(0x00, mpu.regY)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STY Zero Page
|
|
|
|
@Test
|
|
fun test_sty_zp_stores_y_leaves_y_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regY = 0xFF
|
|
// $0000 STY $0010
|
|
writeMem(memory, 0x0000, listOf(0x84, 0x10))
|
|
memory[0x0010] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0x0010])
|
|
assertEquals(0xFF, mpu.regY)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sty_zp_stores_y_leaves_y_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regY = 0x00
|
|
// $0000 STY $0010
|
|
writeMem(memory, 0x0000, listOf(0x84, 0x10))
|
|
memory[0x0010] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010])
|
|
assertEquals(0x00, mpu.regY)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// STY Zero Page, X-Indexed
|
|
|
|
@Test
|
|
fun test_sty_zp_x_indexed_stores_y_leaves_y_and_n_flag_unchanged() {
|
|
val flags = 0xFF and fNEGATIVE.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regY = 0xFF
|
|
mpu.regX = 0x03
|
|
// $0000 STY $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x94, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0x00
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0xFF, memory[0x0010 + mpu.regX])
|
|
assertEquals(0xFF, mpu.regY)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
@Test
|
|
fun test_sty_zp_x_indexed_stores_y_leaves_y_and_z_flag_unchanged() {
|
|
val flags = 0xFF and fZERO.inv()
|
|
mpu.regP.fromInt(flags)
|
|
mpu.regY = 0x00
|
|
mpu.regX = 0x03
|
|
// $0000 STY $0010,X
|
|
writeMem(memory, 0x0000, listOf(0x94, 0x10))
|
|
memory[0x0010 + mpu.regX] = 0xFF
|
|
mpu.step()
|
|
assertEquals(0x0002, mpu.regPC)
|
|
assertEquals(0x00, memory[0x0010 + mpu.regX])
|
|
assertEquals(0x00, mpu.regY)
|
|
assertEquals(flags, mpu.regP.asInt())
|
|
}
|
|
|
|
// TAX
|
|
|
|
@Test
|
|
fun test_tax_transfers_accumulator_into_x() {
|
|
mpu.regA = 0xAB
|
|
mpu.regX = 0x00
|
|
// $0000 TAX
|
|
memory[0x0000] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAB, mpu.regA)
|
|
assertEquals(0xAB, mpu.regX)
|
|
}
|
|
|
|
@Test
|
|
fun test_tax_sets_negative_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x80
|
|
mpu.regX = 0x00
|
|
// $0000 TAX
|
|
memory[0x0000] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_tax_sets_zero_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
mpu.regX = 0xFF
|
|
// $0000 TAX
|
|
memory[0x0000] = 0xAA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
// TAY
|
|
|
|
@Test
|
|
fun test_tay_transfers_accumulator_into_y() {
|
|
mpu.regA = 0xAB
|
|
mpu.regY = 0x00
|
|
// $0000 TAY
|
|
memory[0x0000] = 0xA8
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAB, mpu.regA)
|
|
assertEquals(0xAB, mpu.regY)
|
|
}
|
|
|
|
@Test
|
|
fun test_tay_sets_negative_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regA = 0x80
|
|
mpu.regY = 0x00
|
|
// $0000 TAY
|
|
memory[0x0000] = 0xA8
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertEquals(0x80, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_tay_sets_zero_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regA = 0x00
|
|
mpu.regY = 0xFF
|
|
// $0000 TAY
|
|
memory[0x0000] = 0xA8
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
// TSX
|
|
|
|
@Test
|
|
fun test_tsx_transfers_stack_pointer_into_x() {
|
|
mpu.regSP = 0xAB
|
|
mpu.regX = 0x00
|
|
// $0000 TSX
|
|
memory[0x0000] = 0xBA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAB, mpu.regSP)
|
|
assertEquals(0xAB, mpu.regX)
|
|
}
|
|
|
|
@Test
|
|
fun test_tsx_sets_negative_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regSP = 0x80
|
|
mpu.regX = 0x00
|
|
// $0000 TSX
|
|
memory[0x0000] = 0xBA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regSP)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_tsx_sets_zero_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regSP = 0x00
|
|
mpu.regY = 0xFF
|
|
// $0000 TSX
|
|
memory[0x0000] = 0xBA
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regSP)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
// TXA
|
|
|
|
@Test
|
|
fun test_txa_transfers_x_into_a() {
|
|
mpu.regX = 0xAB
|
|
mpu.regA = 0x00
|
|
// $0000 TXA
|
|
memory[0x0000] = 0x8A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAB, mpu.regA)
|
|
assertEquals(0xAB, mpu.regX)
|
|
}
|
|
|
|
@Test
|
|
fun test_txa_sets_negative_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regX = 0x80
|
|
mpu.regA = 0x00
|
|
// $0000 TXA
|
|
memory[0x0000] = 0x8A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_txa_sets_zero_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regX = 0x00
|
|
mpu.regA = 0xFF
|
|
// $0000 TXA
|
|
memory[0x0000] = 0x8A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertTrue(mpu.regP.Z)
|
|
}
|
|
|
|
// TXS
|
|
|
|
@Test
|
|
fun test_txs_transfers_x_into_stack_pointer() {
|
|
mpu.regX = 0xAB
|
|
// $0000 TXS
|
|
memory[0x0000] = 0x9A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAB, mpu.regSP)
|
|
assertEquals(0xAB, mpu.regX)
|
|
}
|
|
|
|
@Test
|
|
fun test_txs_does_not_set_negative_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regX = 0x80
|
|
// $0000 TXS
|
|
memory[0x0000] = 0x9A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regSP)
|
|
assertEquals(0x80, mpu.regX)
|
|
assertFalse(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_txs_does_not_set_zero_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regX = 0x00
|
|
// $0000 TXS
|
|
memory[0x0000] = 0x9A
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x00, mpu.regSP)
|
|
assertEquals(0x00, mpu.regX)
|
|
assertFalse(mpu.regP.Z)
|
|
}
|
|
|
|
// TYA
|
|
|
|
@Test
|
|
fun test_tya_transfers_y_into_a() {
|
|
mpu.regY = 0xAB
|
|
mpu.regA = 0x00
|
|
// $0000 TYA
|
|
memory[0x0000] = 0x98
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0xAB, mpu.regA)
|
|
assertEquals(0xAB, mpu.regY)
|
|
}
|
|
|
|
@Test
|
|
fun test_tya_sets_negative_flag() {
|
|
mpu.regP.N = false
|
|
mpu.regY = 0x80
|
|
mpu.regA = 0x00
|
|
// $0000 TYA
|
|
memory[0x0000] = 0x98
|
|
mpu.step()
|
|
assertEquals(0x0001, mpu.regPC)
|
|
assertEquals(0x80, mpu.regA)
|
|
assertEquals(0x80, mpu.regY)
|
|
assertTrue(mpu.regP.N)
|
|
}
|
|
|
|
@Test
|
|
fun test_tya_sets_zero_flag() {
|
|
mpu.regP.Z = false
|
|
mpu.regY = 0x00
|
|
mpu.regA = 0xFF
|
|
// $0000 TYA
|
|
memory[0x0000] = 0x98
|
|
mpu.step()
|
|
assertEquals(0x00, mpu.regA)
|
|
assertEquals(0x00, mpu.regY)
|
|
assertTrue(mpu.regP.Z)
|
|
assertEquals(0x0001, mpu.regPC)
|
|
}
|
|
|
|
@Test
|
|
fun test_brk_interrupt() {
|
|
writeMem(memory, 0xFFFE, listOf(0x00, 0x04))
|
|
|
|
writeMem(memory, 0x0000, listOf(0xA9, 0x01, // LDA #$01
|
|
0x00, 0xEA, // BRK + skipped byte
|
|
0xEA, 0xEA, // NOP, NOP
|
|
0xA9, 0x03)) // LDA #$03
|
|
|
|
writeMem(memory, 0x0400, listOf(0xA9, 0x02, // LDA #$02
|
|
0x40)) // RTI
|
|
|
|
mpu.step() // LDA #$01
|
|
assertEquals(0x01, mpu.regA)
|
|
assertEquals(0x0002, mpu.regPC)
|
|
mpu.step() // BRK
|
|
assertEquals(0x0400, mpu.regPC)
|
|
mpu.step() // LDA #$02
|
|
assertEquals(0x02, mpu.regA)
|
|
assertEquals(0x0402, mpu.regPC)
|
|
mpu.step() // RTI
|
|
|
|
assertEquals(0x0004, mpu.regPC)
|
|
mpu.step() // A NOP
|
|
mpu.step() // The second NOP
|
|
|
|
mpu.step() // LDA #$03
|
|
assertEquals(0x03, mpu.regA)
|
|
assertEquals(0x0008, mpu.regPC)
|
|
}
|
|
}
|