diff --git a/README.md b/README.md index 4bf1920..785fe0d 100644 --- a/README.md +++ b/README.md @@ -26,4 +26,4 @@ Properties of this simulator: ## Documentation -Still to be written. For now, +Still to be written. For now, use the source ;-) diff --git a/build.gradle.kts b/build.gradle.kts index 773364d..9da5be5 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,22 +1,29 @@ import org.jetbrains.dokka.gradle.DokkaTask import org.jetbrains.kotlin.gradle.tasks.KotlinCompile import kotlin.math.max +import java.util.Properties + plugins { // Apply the Kotlin JVM plugin to add support for Kotlin on the JVM. id("org.jetbrains.kotlin.jvm") version "1.3.50" id("com.gradle.build-scan") version "2.4.2" id("org.jetbrains.dokka") version "0.9.18" + id("com.jfrog.bintray") version "1.7.3" + id("maven-publish") } - -version = rootProject.file("src/main/resources/version.txt").readText().trim() +val versionProps = Properties().also { + it.load(File("src/main/resources/version.properties").inputStream()) +} +version = versionProps["version"] as String base.archivesBaseName = "ksim65" repositories { // Use jcenter for resolving dependencies. // You can declare any Maven/Ivy/file repository here. jcenter() + maven("https://jitpack.io") } dependencies { diff --git a/src/main/kotlin/razorvine/ksim65/components/Bus.kt b/src/main/kotlin/razorvine/ksim65/Bus.kt similarity index 55% rename from src/main/kotlin/razorvine/ksim65/components/Bus.kt rename to src/main/kotlin/razorvine/ksim65/Bus.kt index b116983..5726b7f 100644 --- a/src/main/kotlin/razorvine/ksim65/components/Bus.kt +++ b/src/main/kotlin/razorvine/ksim65/Bus.kt @@ -1,5 +1,17 @@ -package razorvine.ksim65.components +package razorvine.ksim65 +import razorvine.ksim65.components.Address +import razorvine.ksim65.components.BusComponent +import razorvine.ksim65.components.MemMappedComponent +import razorvine.ksim65.components.UByte + +/** + * The system bus that connects all other components together. + * Usually, there is just a single Bus present. + * + * It distributes reset and clock signals to every connected component. + * Data bytes can be read from the bus or written to the bus. It's distributed to the corresponding component(s). + */ class Bus { private val components = mutableListOf() @@ -25,6 +37,10 @@ class Bus { component.bus = this } + /** + * Read a data byte at the given address. + * The first memory mapped component that listens to that address, will respond. + */ fun read(address: Address): UByte { memComponents.forEach { if (address >= it.startAddress && address <= it.endAddress) @@ -33,6 +49,10 @@ class Bus { return 0xff } + /** + * Write a data byte to the given address. + * Any memory mapped component that listens to the address, will receive the data. + */ fun write(address: Address, data: UByte) { memComponents.forEach { if (address >= it.startAddress && address <= it.endAddress) diff --git a/src/main/kotlin/razorvine/ksim65/components/Cpu6502.kt b/src/main/kotlin/razorvine/ksim65/Cpu6502.kt similarity index 82% rename from src/main/kotlin/razorvine/ksim65/components/Cpu6502.kt rename to src/main/kotlin/razorvine/ksim65/Cpu6502.kt index f5ef910..9bdf959 100644 --- a/src/main/kotlin/razorvine/ksim65/components/Cpu6502.kt +++ b/src/main/kotlin/razorvine/ksim65/Cpu6502.kt @@ -1,5 +1,9 @@ -package razorvine.ksim65.components +package razorvine.ksim65 +import razorvine.ksim65.components.Address +import razorvine.ksim65.components.BusComponent +import razorvine.ksim65.components.MemoryComponent +import razorvine.ksim65.components.UByte /** * 6502 cpu simulation (the NMOS version) including the 'illegal' opcodes. @@ -86,12 +90,12 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { protected class Instruction(val mnemonic: String, val mode: AddrMode, val cycles: Int) - var A: Int = 0 - var X: Int = 0 - var Y: Int = 0 - var SP: Int = 0 - var PC: Address = 0 - val Status = StatusRegister() + var regA: Int = 0 + var regX: Int = 0 + var regY: Int = 0 + var regSP: Int = 0 + var regPC: Address = 0 + val regP = StatusRegister() var currentOpcode: Int = 0 protected set var instrCycles: Int = 0 @@ -137,7 +141,7 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { } fun disassemble(component: MemoryComponent, from: Address, to: Address) = - disassemble(component.cloneContents(), component.startAddress, from, to) + disassemble(component.copyOfMem(), component.startAddress, from, to) fun disassemble(memory: Array, baseAddress: Address, from: Address, to: Address): List { var location = from - baseAddress @@ -246,18 +250,18 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { } override fun reset() { - SP = 0xfd - PC = readWord(RESET_vector) - A = 0 - X = 0 - Y = 0 - Status.C = false - Status.Z = false - Status.I = true - Status.D = false - Status.B = false - Status.V = false - Status.N = false + regSP = 0xfd + regPC = readWord(RESET_vector) + regA = 0 + regX = 0 + regY = 0 + regP.C = false + regP.Z = false + regP.I = true + regP.D = false + regP.B = false + regP.V = false + regP.N = false instrCycles = resetCycles // a reset takes time as well currentOpcode = 0 currentInstruction = instructions[0] @@ -272,17 +276,17 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { currentInstruction = instructions[0] } else { // no interrupt, fetch next instruction from memory - currentOpcode = read(PC) + currentOpcode = read(regPC) currentInstruction = instructions[currentOpcode] tracing?.invoke(logState()) - breakpoints[PC]?.let { breakpoint -> - val oldPC = PC - val result = breakpoint(this, PC) + breakpoints[regPC]?.let { breakpoint -> + val oldPC = regPC + val result = breakpoint(this, regPC) if(result.newPC!=null) - PC = result.newPC - if (PC != oldPC) + regPC = result.newPC + if (regPC != oldPC) return clock() else if(result.newOpcode!=null) { currentOpcode = result.newOpcode @@ -291,11 +295,11 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { } if (stopOnBrk && currentOpcode == 0) { - throw InstructionError("stopped on BRK instruction at ${hexW(PC)}") + throw InstructionError("stopped on BRK instruction at ${hexW(regPC)}") } } - PC++ + regPC++ instrCycles = currentInstruction.cycles applyAddressingMode(currentInstruction.mode) dispatchOpcode(currentOpcode) @@ -317,23 +321,23 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { } fun irq(source: BusComponent) { - if (!Status.I) + if (!regP.I) pendingInterrupt = Pair(false, source) } fun logState(): String = - "cycle:$totalCycles - pc=${hexW(PC)} " + - "A=${hexB(A)} " + - "X=${hexB(X)} " + - "Y=${hexB(Y)} " + - "SP=${hexB(SP)} " + - " n=" + (if (Status.N) "1" else "0") + - " v=" + (if (Status.V) "1" else "0") + - " b=" + (if (Status.B) "1" else "0") + - " d=" + (if (Status.D) "1" else "0") + - " i=" + (if (Status.I) "1" else "0") + - " z=" + (if (Status.Z) "1" else "0") + - " c=" + (if (Status.C) "1" else "0") + + "cycle:$totalCycles - pc=${hexW(regPC)} " + + "A=${hexB(regA)} " + + "X=${hexB(regX)} " + + "Y=${hexB(regY)} " + + "SP=${hexB(regSP)} " + + " n=" + (if (regP.N) "1" else "0") + + " v=" + (if (regP.V) "1" else "0") + + " b=" + (if (regP.B) "1" else "0") + + " d=" + (if (regP.D) "1" else "0") + + " i=" + (if (regP.I) "1" else "0") + + " z=" + (if (regP.Z) "1" else "0") + + " c=" + (if (regP.C) "1" else "0") + " icycles=$instrCycles instr=${hexB(currentOpcode)}:${currentInstruction.mnemonic}" protected fun getFetched() = @@ -345,7 +349,7 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { else read(fetchedAddress) - protected fun readPc(): Int = bus.read(PC++).toInt() + protected fun readPc(): Int = bus.read(regPC++).toInt() protected fun pushStackAddr(address: Address) { val lo = address and 0xff @@ -359,13 +363,13 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { } protected fun pushStack(data: Int) { - write(SP or 0x0100, data) - SP = (SP - 1) and 0xff + write(regSP or 0x0100, data) + regSP = (regSP - 1) and 0xff } protected fun popStack(): Int { - SP = (SP + 1) and 0xff - return read(SP or 0x0100) + regSP = (regSP + 1) and 0xff + return read(regSP or 0x0100) } protected fun popStackAddr(): Address { @@ -379,7 +383,7 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { protected fun write(address: Address, data: Int) = bus.write(address, data.toShort()) // opcodes table from http://www.oxyron.de/html/opcodes02.html - protected open val instructions: Array by lazy { + protected open val instructions: Array = listOf( /* 00 */ Instruction("brk", AddrMode.Imp, 7), /* 01 */ Instruction("ora", AddrMode.IzX, 6), @@ -638,12 +642,11 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { /* fe */ Instruction("inc", AddrMode.AbsX, 7), /* ff */ Instruction("isc", AddrMode.AbsX, 7) ).toTypedArray() - } protected open fun applyAddressingMode(addrMode: AddrMode) { when (addrMode) { AddrMode.Imp, AddrMode.Acc -> { - fetchedData = A + fetchedData = regA } AddrMode.Imm -> { fetchedData = readPc() @@ -653,18 +656,18 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { } AddrMode.ZpX -> { // note: zeropage index will not leave Zp when page boundary is crossed - fetchedAddress = (readPc() + X) and 0xff + fetchedAddress = (readPc() + regX) and 0xff } AddrMode.ZpY -> { // note: zeropage index will not leave Zp when page boundary is crossed - fetchedAddress = (readPc() + Y) and 0xff + fetchedAddress = (readPc() + regY) and 0xff } AddrMode.Rel -> { val relative = readPc() fetchedAddress = if (relative >= 0x80) { - PC - (256 - relative) and 0xffff + regPC - (256 - relative) and 0xffff } else - PC + relative and 0xffff + regPC + relative and 0xffff } AddrMode.Abs -> { val lo = readPc() @@ -674,12 +677,12 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { AddrMode.AbsX -> { val lo = readPc() val hi = readPc() - fetchedAddress = X + (lo or (hi shl 8)) and 0xffff + fetchedAddress = regX + (lo or (hi shl 8)) and 0xffff } AddrMode.AbsY -> { val lo = readPc() val hi = readPc() - fetchedAddress = Y + (lo or (hi shl 8)) and 0xffff + fetchedAddress = regY + (lo or (hi shl 8)) and 0xffff } AddrMode.Ind -> { // not able to fetch an address which crosses the page boundary (6502, fixed in 65C02) @@ -700,8 +703,8 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { AddrMode.IzX -> { // note: not able to fetch an adress which crosses the page boundary fetchedAddress = readPc() - val lo = read((fetchedAddress + X) and 0xff) - val hi = read((fetchedAddress + X + 1) and 0xff) + val lo = read((fetchedAddress + regX) and 0xff) + val hi = read((fetchedAddress + regX + 1) and 0xff) fetchedAddress = lo or (hi shl 8) } AddrMode.IzY -> { @@ -709,7 +712,7 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { fetchedAddress = readPc() val lo = read(fetchedAddress) val hi = read((fetchedAddress + 1) and 0xff) - fetchedAddress = Y + (lo or (hi shl 8)) and 0xffff + fetchedAddress = regY + (lo or (hi shl 8)) and 0xffff } AddrMode.Zpr, AddrMode.Izp, AddrMode.IaX -> { // addressing mode used by the 65C02 only @@ -986,87 +989,87 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { protected open fun iAdc() { val operand = getFetched() - if (Status.D) { + if (regP.D) { // BCD add // see http://www.6502.org/tutorials/decimal_mode.html // and http://nesdev.com/6502.txt // and https://sourceforge.net/p/vice-emu/code/HEAD/tree/trunk/vice/src/6510core.c#l598 // (the implementation below is based on the code used by Vice) - var tmp = (A and 0xf) + (operand and 0xf) + (if (Status.C) 1 else 0) + var tmp = (regA and 0xf) + (operand and 0xf) + (if (regP.C) 1 else 0) if (tmp > 9) tmp += 6 tmp = if (tmp <= 0x0f) { - (tmp and 0xf) + (A and 0xf0) + (operand and 0xf0) + (tmp and 0xf) + (regA and 0xf0) + (operand and 0xf0) } else { - (tmp and 0xf) + (A and 0xf0) + (operand and 0xf0) + 0x10 + (tmp and 0xf) + (regA and 0xf0) + (operand and 0xf0) + 0x10 } - Status.Z = A + operand + (if (Status.C) 1 else 0) and 0xff == 0 - Status.N = tmp and 0b10000000 != 0 - Status.V = (A xor tmp) and 0x80 != 0 && (A xor operand) and 0b10000000 == 0 + regP.Z = regA + operand + (if (regP.C) 1 else 0) and 0xff == 0 + regP.N = tmp and 0b10000000 != 0 + regP.V = (regA xor tmp) and 0x80 != 0 && (regA xor operand) and 0b10000000 == 0 if (tmp and 0x1f0 > 0x90) tmp += 0x60 - Status.C = tmp > 0xf0 // original: (tmp and 0xff0) > 0xf0 - A = tmp and 0xff + regP.C = tmp > 0xf0 // original: (tmp and 0xff0) > 0xf0 + regA = tmp and 0xff } else { // normal add - val tmp = operand + A + if (Status.C) 1 else 0 - Status.N = (tmp and 0b10000000) != 0 - Status.Z = (tmp and 0xff) == 0 - Status.V = (A xor operand).inv() and (A xor tmp) and 0b10000000 != 0 - Status.C = tmp > 0xff - A = tmp and 0xff + val tmp = operand + regA + if (regP.C) 1 else 0 + regP.N = (tmp and 0b10000000) != 0 + regP.Z = (tmp and 0xff) == 0 + regP.V = (regA xor operand).inv() and (regA xor tmp) and 0b10000000 != 0 + regP.C = tmp > 0xff + regA = tmp and 0xff } } protected fun iAnd() { - A = A and getFetched() - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = regA and getFetched() + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } protected fun iAsl() { if (currentInstruction.mode == AddrMode.Acc) { - Status.C = (A and 0b10000000) != 0 - A = (A shl 1) and 0xff - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regP.C = (regA and 0b10000000) != 0 + regA = (regA shl 1) and 0xff + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } else { val data = read(fetchedAddress) - Status.C = (data and 0b10000000) != 0 + regP.C = (data and 0b10000000) != 0 val shifted = (data shl 1) and 0xff write(fetchedAddress, shifted) - Status.Z = shifted == 0 - Status.N = (shifted and 0b10000000) != 0 + regP.Z = shifted == 0 + regP.N = (shifted and 0b10000000) != 0 } } protected fun iBcc() { - if (!Status.C) PC = fetchedAddress + if (!regP.C) regPC = fetchedAddress } protected fun iBcs() { - if (Status.C) PC = fetchedAddress + if (regP.C) regPC = fetchedAddress } protected fun iBeq() { - if (Status.Z) PC = fetchedAddress + if (regP.Z) regPC = fetchedAddress } protected open fun iBit() { val operand = getFetched() - Status.Z = (A and operand) == 0 - Status.V = (operand and 0b01000000) != 0 - Status.N = (operand and 0b10000000) != 0 + regP.Z = (regA and operand) == 0 + regP.V = (operand and 0b01000000) != 0 + regP.N = (operand and 0b10000000) != 0 } protected fun iBmi() { - if (Status.N) PC = fetchedAddress + if (regP.N) regPC = fetchedAddress } protected fun iBne() { - if (!Status.Z) PC = fetchedAddress + if (!regP.Z) regPC = fetchedAddress } protected fun iBpl() { - if (!Status.N) PC = fetchedAddress + if (!regP.N) regPC = fetchedAddress } protected open fun iBrk() { @@ -1074,309 +1077,309 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() { val interrupt = pendingInterrupt val nmi = interrupt?.first == true if (interrupt != null) { - pushStackAddr(PC - 1) + pushStackAddr(regPC - 1) } else { - PC++ - pushStackAddr(PC) + regPC++ + pushStackAddr(regPC) } - Status.B = interrupt == null - pushStack(Status) - Status.I = true // interrupts are now disabled + regP.B = interrupt == null + pushStack(regP) + regP.I = true // interrupts are now disabled // NMOS 6502 doesn't clear the D flag (CMOS 65C02 version does...) - PC = readWord(if (nmi) NMI_vector else IRQ_vector) + regPC = readWord(if (nmi) NMI_vector else IRQ_vector) pendingInterrupt = null } protected fun iBvc() { - if (!Status.V) PC = fetchedAddress + if (!regP.V) regPC = fetchedAddress } protected fun iBvs() { - if (Status.V) PC = fetchedAddress + if (regP.V) regPC = fetchedAddress } protected fun iClc() { - Status.C = false + regP.C = false } protected fun iCld() { - Status.D = false + regP.D = false } protected fun iCli() { - Status.I = false + regP.I = false } protected fun iClv() { - Status.V = false + regP.V = false } protected fun iCmp() { val fetched = getFetched() - Status.C = A >= fetched - Status.Z = A == fetched - Status.N = ((A - fetched) and 0b10000000) != 0 + regP.C = regA >= fetched + regP.Z = regA == fetched + regP.N = ((regA - fetched) and 0b10000000) != 0 } protected fun iCpx() { val fetched = getFetched() - Status.C = X >= fetched - Status.Z = X == fetched - Status.N = ((X - fetched) and 0b10000000) != 0 + regP.C = regX >= fetched + regP.Z = regX == fetched + regP.N = ((regX - fetched) and 0b10000000) != 0 } protected fun iCpy() { val fetched = getFetched() - Status.C = Y >= fetched - Status.Z = Y == fetched - Status.N = ((Y - fetched) and 0b10000000) != 0 + regP.C = regY >= fetched + regP.Z = regY == fetched + regP.N = ((regY - fetched) and 0b10000000) != 0 } protected open fun iDec() { val data = (read(fetchedAddress) - 1) and 0xff write(fetchedAddress, data) - Status.Z = data == 0 - Status.N = (data and 0b10000000) != 0 + regP.Z = data == 0 + regP.N = (data and 0b10000000) != 0 } protected fun iDex() { - X = (X - 1) and 0xff - Status.Z = X == 0 - Status.N = (X and 0b10000000) != 0 + regX = (regX - 1) and 0xff + regP.Z = regX == 0 + regP.N = (regX and 0b10000000) != 0 } protected fun iDey() { - Y = (Y - 1) and 0xff - Status.Z = Y == 0 - Status.N = (Y and 0b10000000) != 0 + regY = (regY - 1) and 0xff + regP.Z = regY == 0 + regP.N = (regY and 0b10000000) != 0 } protected fun iEor() { - A = A xor getFetched() - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = regA xor getFetched() + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } protected open fun iInc() { val data = (read(fetchedAddress) + 1) and 0xff write(fetchedAddress, data) - Status.Z = data == 0 - Status.N = (data and 0b10000000) != 0 + regP.Z = data == 0 + regP.N = (data and 0b10000000) != 0 } protected fun iInx() { - X = (X + 1) and 0xff - Status.Z = X == 0 - Status.N = (X and 0b10000000) != 0 + regX = (regX + 1) and 0xff + regP.Z = regX == 0 + regP.N = (regX and 0b10000000) != 0 } protected fun iIny() { - Y = (Y + 1) and 0xff - Status.Z = Y == 0 - Status.N = (Y and 0b10000000) != 0 + regY = (regY + 1) and 0xff + regP.Z = regY == 0 + regP.N = (regY and 0b10000000) != 0 } protected fun iJmp() { - PC = fetchedAddress + regPC = fetchedAddress } protected fun iJsr() { - pushStackAddr(PC - 1) - PC = fetchedAddress + pushStackAddr(regPC - 1) + regPC = fetchedAddress } protected fun iLda() { - A = getFetched() - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = getFetched() + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } protected fun iLdx() { - X = getFetched() - Status.Z = X == 0 - Status.N = (X and 0b10000000) != 0 + regX = getFetched() + regP.Z = regX == 0 + regP.N = (regX and 0b10000000) != 0 } protected fun iLdy() { - Y = getFetched() - Status.Z = Y == 0 - Status.N = (Y and 0b10000000) != 0 + regY = getFetched() + regP.Z = regY == 0 + regP.N = (regY and 0b10000000) != 0 } protected fun iLsr() { if (currentInstruction.mode == AddrMode.Acc) { - Status.C = (A and 1) == 1 - A = A ushr 1 - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regP.C = (regA and 1) == 1 + regA = regA ushr 1 + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } else { val data = read(fetchedAddress) - Status.C = (data and 1) == 1 + regP.C = (data and 1) == 1 val shifted = data ushr 1 write(fetchedAddress, shifted) - Status.Z = shifted == 0 - Status.N = (shifted and 0b10000000) != 0 + regP.Z = shifted == 0 + regP.N = (shifted and 0b10000000) != 0 } } protected fun iNop() {} protected fun iOra() { - A = A or getFetched() - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = regA or getFetched() + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } protected fun iPha() { - pushStack(A) + pushStack(regA) } protected fun iPhp() { - val origBreakflag = Status.B - Status.B = true - pushStack(Status) - Status.B = origBreakflag + val origBreakflag = regP.B + regP.B = true + pushStack(regP) + regP.B = origBreakflag } protected fun iPla() { - A = popStack() - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = popStack() + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } protected fun iPlp() { - Status.fromByte(popStack()) - Status.B = true // break is always 1 except when pushing on stack + regP.fromByte(popStack()) + regP.B = true // break is always 1 except when pushing on stack } protected fun iRol() { - val oldCarry = Status.C + val oldCarry = regP.C if (currentInstruction.mode == AddrMode.Acc) { - Status.C = (A and 0b10000000) != 0 - A = (A shl 1 and 0xff) or (if (oldCarry) 1 else 0) - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regP.C = (regA and 0b10000000) != 0 + regA = (regA shl 1 and 0xff) or (if (oldCarry) 1 else 0) + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } else { val data = read(fetchedAddress) - Status.C = (data and 0b10000000) != 0 + regP.C = (data and 0b10000000) != 0 val shifted = (data shl 1 and 0xff) or (if (oldCarry) 1 else 0) write(fetchedAddress, shifted) - Status.Z = shifted == 0 - Status.N = (shifted and 0b10000000) != 0 + regP.Z = shifted == 0 + regP.N = (shifted and 0b10000000) != 0 } } protected fun iRor() { - val oldCarry = Status.C + val oldCarry = regP.C if (currentInstruction.mode == AddrMode.Acc) { - Status.C = (A and 1) == 1 - A = (A ushr 1) or (if (oldCarry) 0b10000000 else 0) - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regP.C = (regA and 1) == 1 + regA = (regA ushr 1) or (if (oldCarry) 0b10000000 else 0) + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } else { val data = read(fetchedAddress) - Status.C = (data and 1) == 1 + regP.C = (data and 1) == 1 val shifted = (data ushr 1) or (if (oldCarry) 0b10000000 else 0) write(fetchedAddress, shifted) - Status.Z = shifted == 0 - Status.N = (shifted and 0b10000000) != 0 + regP.Z = shifted == 0 + regP.N = (shifted and 0b10000000) != 0 } } protected fun iRti() { - Status.fromByte(popStack()) - Status.B = true // break is always 1 except when pushing on stack - PC = popStackAddr() + regP.fromByte(popStack()) + regP.B = true // break is always 1 except when pushing on stack + regPC = popStackAddr() } protected fun iRts() { - PC = popStackAddr() - PC = (PC + 1) and 0xffff + regPC = popStackAddr() + regPC = (regPC + 1) and 0xffff } protected open fun iSbc() { val operand = getFetched() - val tmp = (A - operand - if (Status.C) 0 else 1) and 0xffff - Status.V = (A xor operand) and (A xor tmp) and 0b10000000 != 0 - if (Status.D) { + val tmp = (regA - operand - if (regP.C) 0 else 1) and 0xffff + regP.V = (regA xor operand) and (regA xor tmp) and 0b10000000 != 0 + if (regP.D) { // BCD subtract // see http://www.6502.org/tutorials/decimal_mode.html // and http://nesdev.com/6502.txt // and https://sourceforge.net/p/vice-emu/code/HEAD/tree/trunk/vice/src/6510core.c#l1396 // (the implementation below is based on the code used by Vice) - var tmpA = ((A and 0xf) - (operand and 0xf) - if (Status.C) 0 else 1) and 0xffff + var tmpA = ((regA and 0xf) - (operand and 0xf) - if (regP.C) 0 else 1) and 0xffff tmpA = if ((tmpA and 0x10) != 0) { - ((tmpA - 6) and 0xf) or (A and 0xf0) - (operand and 0xf0) - 0x10 + ((tmpA - 6) and 0xf) or (regA and 0xf0) - (operand and 0xf0) - 0x10 } else { - (tmpA and 0xf) or (A and 0xf0) - (operand and 0xf0) + (tmpA and 0xf) or (regA and 0xf0) - (operand and 0xf0) } if ((tmpA and 0x100) != 0) tmpA -= 0x60 - A = tmpA and 0xff + regA = tmpA and 0xff } else { // normal subtract - A = tmp and 0xff + regA = tmp and 0xff } - Status.C = tmp < 0x100 - Status.Z = (tmp and 0xff) == 0 - Status.N = (tmp and 0b10000000) != 0 + regP.C = tmp < 0x100 + regP.Z = (tmp and 0xff) == 0 + regP.N = (tmp and 0b10000000) != 0 } protected fun iSec() { - Status.C = true + regP.C = true } protected fun iSed() { - Status.D = true + regP.D = true } protected fun iSei() { - Status.I = true + regP.I = true } protected fun iSta() { - write(fetchedAddress, A) + write(fetchedAddress, regA) } protected fun iStx() { - write(fetchedAddress, X) + write(fetchedAddress, regX) } protected fun iSty() { - write(fetchedAddress, Y) + write(fetchedAddress, regY) } protected fun iTax() { - X = A - Status.Z = X == 0 - Status.N = (X and 0b10000000) != 0 + regX = regA + regP.Z = regX == 0 + regP.N = (regX and 0b10000000) != 0 } protected fun iTay() { - Y = A - Status.Z = Y == 0 - Status.N = (Y and 0b10000000) != 0 + regY = regA + regP.Z = regY == 0 + regP.N = (regY and 0b10000000) != 0 } protected fun iTsx() { - X = SP - Status.Z = X == 0 - Status.N = (X and 0b10000000) != 0 + regX = regSP + regP.Z = regX == 0 + regP.N = (regX and 0b10000000) != 0 } protected fun iTxa() { - A = X - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = regX + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } protected fun iTxs() { - SP = X + regSP = regX } protected fun iTya() { - A = Y - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = regY + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } // unofficial/illegal 6502 instructions diff --git a/src/main/kotlin/razorvine/ksim65/components/Cpu65C02.kt b/src/main/kotlin/razorvine/ksim65/Cpu65C02.kt similarity index 90% rename from src/main/kotlin/razorvine/ksim65/components/Cpu65C02.kt rename to src/main/kotlin/razorvine/ksim65/Cpu65C02.kt index 143fdd5..dad9224 100644 --- a/src/main/kotlin/razorvine/ksim65/components/Cpu65C02.kt +++ b/src/main/kotlin/razorvine/ksim65/Cpu65C02.kt @@ -1,4 +1,6 @@ -package razorvine.ksim65.components +package razorvine.ksim65 + +import razorvine.ksim65.components.Address /** * 65C02 cpu simulation (the CMOS version of the 6502). @@ -34,7 +36,7 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) { Wait.Stopped -> { if (pendingInterrupt != null) { // jump to reset vector after hardware interrupt - PC = readWord(RESET_vector) + regPC = readWord(RESET_vector) } } } @@ -80,9 +82,9 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) { fetchedAddress = readPc() val relative = readPc() fetchedAddressZpr = if (relative >= 0x80) { - PC - (256 - relative) and 0xffff + regPC - (256 - relative) and 0xffff } else - PC + relative and 0xffff + regPC + relative and 0xffff } AddrMode.Izp -> { // addressing mode used by the 65C02 only @@ -96,8 +98,8 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) { var lo = readPc() var hi = readPc() fetchedAddress = lo or (hi shl 8) - lo = read((fetchedAddress + X) and 0xffff) - hi = read((fetchedAddress + X + 1) and 0xffff) + lo = read((fetchedAddress + regX) and 0xffff) + hi = read((fetchedAddress + regX + 1) and 0xffff) fetchedAddress = lo or (hi shl 8) } } @@ -367,7 +369,7 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) { } // opcode list: http://www.oxyron.de/html/opcodesc02.html - override val instructions: Array by lazy { + override val instructions: Array = listOf( /* 00 */ Instruction("brk", AddrMode.Imp, 7), /* 01 */ Instruction("ora", AddrMode.IzX, 6), @@ -626,63 +628,62 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) { /* fe */ Instruction("inc", AddrMode.AbsX, 7), /* ff */ Instruction("bbs7", AddrMode.Zpr, 5) ).toTypedArray() - } override fun iBrk() { // handle BRK ('software interrupt') or a real hardware IRQ val interrupt = pendingInterrupt val nmi = interrupt?.first == true if (interrupt != null) { - pushStackAddr(PC - 1) + pushStackAddr(regPC - 1) } else { - PC++ - pushStackAddr(PC) + regPC++ + pushStackAddr(regPC) } - Status.B = interrupt == null - pushStack(Status) - Status.I = true // interrupts are now disabled - Status.D = false // this is different from NMOS 6502 - PC = readWord(if (nmi) Cpu6502.NMI_vector else Cpu6502.IRQ_vector) + regP.B = interrupt == null + pushStack(regP) + regP.I = true // interrupts are now disabled + regP.D = false // this is different from NMOS 6502 + regPC = readWord(if (nmi) Cpu6502.NMI_vector else Cpu6502.IRQ_vector) pendingInterrupt = null } override fun iBit() { val data = getFetched() - Status.Z = (A and data) == 0 + regP.Z = (regA and data) == 0 if (currentInstruction.mode != AddrMode.Imm) { - Status.V = (data and 0b01000000) != 0 - Status.N = (data and 0b10000000) != 0 + regP.V = (data and 0b01000000) != 0 + regP.N = (data and 0b10000000) != 0 } } override fun iAdc() { val value = getFetched() - if (Status.D) { + if (regP.D) { // BCD add // see http://www.6502.org/tutorials/decimal_mode.html // and https://sourceforge.net/p/vice-emu/code/HEAD/tree/trunk/vice/src/65c02core.c#l542 // (the implementation below is based on the code used by Vice) - var tmp = (A and 0x0f) + (value and 0x0f) + if (Status.C) 1 else 0 - var tmp2 = (A and 0xf0) + (value and 0xf0) + var tmp = (regA and 0x0f) + (value and 0x0f) + if (regP.C) 1 else 0 + var tmp2 = (regA and 0xf0) + (value and 0xf0) if (tmp > 9) { tmp2 += 0x10 tmp += 6 } - Status.V = (A xor value).inv() and (A xor tmp2) and 0b10000000 != 0 + regP.V = (regA xor value).inv() and (regA xor tmp2) and 0b10000000 != 0 if (tmp2 > 0x90) tmp2 += 0x60 - Status.C = tmp2 >= 0x100 + regP.C = tmp2 >= 0x100 tmp = (tmp and 0x0f) + (tmp2 and 0xf0) - Status.N = (tmp and 0b10000000) != 0 - Status.Z = tmp == 0 - A = tmp and 0xff + regP.N = (tmp and 0b10000000) != 0 + regP.Z = tmp == 0 + regA = tmp and 0xff } else { // normal add (identical to 6502) - val tmp = value + A + if (Status.C) 1 else 0 - Status.N = (tmp and 0b10000000) != 0 - Status.Z = (tmp and 0xff) == 0 - Status.V = (A xor value).inv() and (A xor tmp) and 0b10000000 != 0 - Status.C = tmp > 0xff - A = tmp and 0xff + val tmp = value + regA + if (regP.C) 1 else 0 + regP.N = (tmp and 0b10000000) != 0 + regP.Z = (tmp and 0xff) == 0 + regP.V = (regA xor value).inv() and (regA xor tmp) and 0b10000000 != 0 + regP.C = tmp > 0xff + regA = tmp and 0xff } } @@ -691,50 +692,50 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) { // and https://sourceforge.net/p/vice-emu/code/HEAD/tree/trunk/vice/src/65c02core.c#l1205 // (the implementation below is based on the code used by Vice) val value = getFetched() - var tmp = (A - value - if (Status.C) 0 else 1) and 0xffff - Status.V = (A xor tmp) and (A xor value) and 0b10000000 != 0 - if (Status.D) { + var tmp = (regA - value - if (regP.C) 0 else 1) and 0xffff + regP.V = (regA xor tmp) and (regA xor value) and 0b10000000 != 0 + if (regP.D) { if (tmp > 0xff) tmp = (tmp - 0x60) and 0xffff - val tmp2 = ((A and 0x0f) - (value and 0x0f) - if (Status.C) 0 else 1) and 0xffff + val tmp2 = ((regA and 0x0f) - (value and 0x0f) - if (regP.C) 0 else 1) and 0xffff if (tmp2 > 0xff) tmp -= 6 } - Status.C = (A - if (Status.C) 0 else 1) >= value - Status.Z = (tmp and 0xff) == 0 - Status.N = (tmp and 0b10000000) != 0 - A = tmp and 0xff + regP.C = (regA - if (regP.C) 0 else 1) >= value + regP.Z = (tmp and 0xff) == 0 + regP.N = (tmp and 0b10000000) != 0 + regA = tmp and 0xff } override fun iDec() { if (currentInstruction.mode == AddrMode.Acc) { - A = (A - 1) and 0xff - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = (regA - 1) and 0xff + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } else super.iDec() } override fun iInc() { if (currentInstruction.mode == AddrMode.Acc) { - A = (A + 1) and 0xff - Status.Z = A == 0 - Status.N = (A and 0b10000000) != 0 + regA = (regA + 1) and 0xff + regP.Z = regA == 0 + regP.N = (regA and 0b10000000) != 0 } else super.iInc() } private fun iBra() { // unconditional branch - PC = fetchedAddress + regPC = fetchedAddress } private fun iTrb() { val data = getFetched() - Status.Z = data and A == 0 - write(fetchedAddress, data and A.inv()) + regP.Z = data and regA == 0 + write(fetchedAddress, data and regA.inv()) } private fun iTsb() { val data = getFetched() - Status.Z = data and A == 0 - write(fetchedAddress, data or A) + regP.Z = data and regA == 0 + write(fetchedAddress, data or regA) } private fun iStz() { @@ -750,119 +751,119 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) { } private fun iPhx() { - pushStack(X) + pushStack(regX) } private fun iPlx() { - X = popStack() - Status.Z = X == 0 - Status.N = (X and 0b10000000) != 0 + regX = popStack() + regP.Z = regX == 0 + regP.N = (regX and 0b10000000) != 0 } private fun iPhy() { - pushStack(Y) + pushStack(regY) } private fun iPly() { - Y = popStack() - Status.Z = Y == 0 - Status.N = (Y and 0b10000000) != 0 + regY = popStack() + regP.Z = regY == 0 + regP.N = (regY and 0b10000000) != 0 } private fun iBbr0() { val data = getFetched() if (data and 1 == 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbr1() { val data = getFetched() if (data and 2 == 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbr2() { val data = getFetched() if (data and 4 == 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbr3() { val data = getFetched() if (data and 8 == 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbr4() { val data = getFetched() if (data and 16 == 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbr5() { val data = getFetched() if (data and 32 == 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbr6() { val data = getFetched() if (data and 64 == 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbr7() { val data = getFetched() if (data and 128 == 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbs0() { val data = getFetched() if (data and 1 != 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbs1() { val data = getFetched() if (data and 2 != 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbs2() { val data = getFetched() if (data and 4 != 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbs3() { val data = getFetched() if (data and 8 != 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbs4() { val data = getFetched() if (data and 16 != 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbs5() { val data = getFetched() if (data and 32 != 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbs6() { val data = getFetched() if (data and 64 != 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iBbs7() { val data = getFetched() if (data and 128 != 0) - PC = fetchedAddressZpr + regPC = fetchedAddressZpr } private fun iSmb0() { diff --git a/src/main/kotlin/razorvine/ksim65/Version.kt b/src/main/kotlin/razorvine/ksim65/Version.kt new file mode 100644 index 0000000..717bc9f --- /dev/null +++ b/src/main/kotlin/razorvine/ksim65/Version.kt @@ -0,0 +1,16 @@ +package razorvine.ksim65 + +import java.util.* + +object Version { + val version: String by lazy { + val props = Properties() + props.load(javaClass.getResourceAsStream("/version.properties")) + props["version"] as String + } + + val copyright: String by lazy { + "KSim65 6502 cpu simulator v$version by Irmen de Jong (irmen@razorvine.net)" + + "\nThis software is free and licensed under the MIT open-source license\n" + } +} diff --git a/src/main/kotlin/razorvine/ksim65/components/Component.kt b/src/main/kotlin/razorvine/ksim65/components/Component.kt index 4c1c80f..5635281 100644 --- a/src/main/kotlin/razorvine/ksim65/components/Component.kt +++ b/src/main/kotlin/razorvine/ksim65/components/Component.kt @@ -1,9 +1,14 @@ package razorvine.ksim65.components +import razorvine.ksim65.Bus + typealias UByte = Short typealias Address = Int +/** + * Base class for any component connected to the system bus. + */ abstract class BusComponent { lateinit var bus: Bus @@ -11,6 +16,10 @@ abstract class BusComponent { abstract fun reset() } +/** + * Base class for components that have registers mapped into the cpu's address space. + * Most I/O components fall into this category. + */ abstract class MemMappedComponent(val startAddress: Address, val endAddress: Address) : BusComponent() { abstract operator fun get(address: Address): UByte abstract operator fun set(address: Address, data: UByte) @@ -38,7 +47,10 @@ abstract class MemMappedComponent(val startAddress: Address, val endAddress: Add } } +/** + * Base class for components that actually contain memory (RAM or ROM chips). + */ abstract class MemoryComponent(startAddress: Address, endAddress: Address) : MemMappedComponent(startAddress, endAddress) { - abstract fun cloneContents(): Array + abstract fun copyOfMem(): Array } diff --git a/src/main/kotlin/razorvine/ksim65/components/ParallelPort.kt b/src/main/kotlin/razorvine/ksim65/components/ParallelPort.kt index b08dc9b..3a4e7eb 100644 --- a/src/main/kotlin/razorvine/ksim65/components/ParallelPort.kt +++ b/src/main/kotlin/razorvine/ksim65/components/ParallelPort.kt @@ -1,9 +1,12 @@ package razorvine.ksim65.components /** - * A parallel output device (basically, prints bytes as characters to the screen) - * First address = data byte (8 parallel bits) - * Second address = control byte (bit 0 high = write byte) + * A simple parallel output device (basically, prints bytes as characters to the console) + * + * byte value + * ---- --------- + * 00 data (the 8 parallel bits) + * 01 control latch (set bit 0 to write the data byte) */ class ParallelPort(startAddress: Address, endAddress: Address) : MemMappedComponent(startAddress, endAddress) { private var dataByte: UByte = 0 diff --git a/src/main/kotlin/razorvine/ksim65/components/Ram.kt b/src/main/kotlin/razorvine/ksim65/components/Ram.kt index f2b8b18..9065fd9 100644 --- a/src/main/kotlin/razorvine/ksim65/components/Ram.kt +++ b/src/main/kotlin/razorvine/ksim65/components/Ram.kt @@ -3,6 +3,9 @@ package razorvine.ksim65.components import java.io.File import java.net.URL +/** + * A RAM chip with read/write memory. + */ class Ram(startAddress: Address, endAddress: Address) : MemoryComponent(startAddress, endAddress) { private val memory = ShortArray(endAddress - startAddress + 1) @@ -12,7 +15,7 @@ class Ram(startAddress: Address, endAddress: Address) : MemoryComponent(startAdd memory[address - startAddress] = data } - override fun cloneContents(): Array = memory.toTypedArray() + override fun copyOfMem(): Array = memory.toTypedArray() override fun clock() {} diff --git a/src/main/kotlin/razorvine/ksim65/components/RealTimeClock.kt b/src/main/kotlin/razorvine/ksim65/components/RealTimeClock.kt index a59acde..8691236 100644 --- a/src/main/kotlin/razorvine/ksim65/components/RealTimeClock.kt +++ b/src/main/kotlin/razorvine/ksim65/components/RealTimeClock.kt @@ -5,17 +5,20 @@ import java.time.LocalTime /** - * A real-time clock (time of day clock). + * A real-time time of day clock. + * (System timers are elsewhere) + * * byte value - * 00 year (lsb) - * 01 year (msb) - * 02 month, 1-12 - * 03 day, 1-31 - * 04 hour, 0-23 - * 05 minute, 0-59 - * 06 second, 0-59 - * 07 millisecond, 0-999 (lsb) - * 08 millisecond, 0-999 (msb) + * ---- ---------- + * 00 year (lsb) + * 01 year (msb) + * 02 month, 1-12 + * 03 day, 1-31 + * 04 hour, 0-23 + * 05 minute, 0-59 + * 06 second, 0-59 + * 07 millisecond, 0-999 (lsb) + * 08 millisecond, 0-999 (msb) */ class RealTimeClock(startAddress: Address, endAddress: Address) : MemMappedComponent(startAddress, endAddress) { diff --git a/src/main/kotlin/razorvine/ksim65/components/Rom.kt b/src/main/kotlin/razorvine/ksim65/components/Rom.kt index 38df04a..98f0842 100644 --- a/src/main/kotlin/razorvine/ksim65/components/Rom.kt +++ b/src/main/kotlin/razorvine/ksim65/components/Rom.kt @@ -1,5 +1,8 @@ package razorvine.ksim65.components +/** + * A ROM chip (read-only memory). + */ class Rom(startAddress: Address, endAddress: Address, data: Array? = null) : MemoryComponent(startAddress, endAddress) { private val memory = if (data == null) @@ -13,8 +16,8 @@ class Rom(startAddress: Address, endAddress: Address, data: Array? = null } override operator fun get(address: Address): UByte = memory[address - startAddress] - override operator fun set(address: Address, data: UByte) {} - override fun cloneContents(): Array = memory.toTypedArray() + override operator fun set(address: Address, data: UByte) { /* read-only */ } + override fun copyOfMem(): Array = memory.toTypedArray() override fun clock() {} override fun reset() {} } diff --git a/src/main/kotlin/razorvine/ksim65/components/Timer.kt b/src/main/kotlin/razorvine/ksim65/components/Timer.kt index 447d16f..6fb8b51 100644 --- a/src/main/kotlin/razorvine/ksim65/components/Timer.kt +++ b/src/main/kotlin/razorvine/ksim65/components/Timer.kt @@ -1,12 +1,17 @@ package razorvine.ksim65.components +import razorvine.ksim65.Cpu6502 + /** * A programmable timer. Causes an IRQ or NMI at specified 24-bits intervals. + * * byte value + * ---- -------------- * 00 control register bit 0=enable bit 1=nmi (instead of irq) * 01 24 bits interval value, bits 0-7 (lo) * 02 24 bits interval value, bits 8-15 (mid) * 03 24 bits interval value, bits 16-23 (hi) + * */ class Timer(startAddress: Address, endAddress: Address, val cpu: Cpu6502) : MemMappedComponent(startAddress, endAddress) { private var counter: Int = 0 diff --git a/src/main/kotlin/razorvine/ksim65/Sim65Main.kt b/src/main/kotlin/testmain/Sim65Main.kt similarity index 71% rename from src/main/kotlin/razorvine/ksim65/Sim65Main.kt rename to src/main/kotlin/testmain/Sim65Main.kt index e01a58b..223f47f 100644 --- a/src/main/kotlin/razorvine/ksim65/Sim65Main.kt +++ b/src/main/kotlin/testmain/Sim65Main.kt @@ -1,22 +1,16 @@ -package razorvine.ksim65 +package testmain +import razorvine.ksim65.Bus +import razorvine.ksim65.Cpu6502 +import razorvine.ksim65.Version import razorvine.ksim65.components.* -import razorvine.ksim65.components.Cpu6502.Companion.IRQ_vector -import razorvine.ksim65.components.Cpu6502.Companion.NMI_vector -import razorvine.ksim65.components.Cpu6502.Companion.RESET_vector fun main(args: Array) { - printSoftwareHeader() + println(Version.copyright) startSimulator(args) } -internal fun printSoftwareHeader() { - val buildVersion = object {}.javaClass.getResource("/version.txt").readText().trim() - println("\nKSim65 6502 cpu simulator v$buildVersion by Irmen de Jong (irmen@razorvine.net)") - println("This software is free and licensed under the MIT open-source license\n") -} - private fun startSimulator(args: Array) { @@ -25,12 +19,12 @@ private fun startSimulator(args: Array) { // it determines the priority of reads and writes. val cpu = Cpu6502(true) val ram = Ram(0, 0xffff) - ram[RESET_vector] = 0x00 - ram[RESET_vector + 1] = 0x10 - ram[IRQ_vector] = 0x00 - ram[IRQ_vector + 1] = 0x20 - ram[NMI_vector] = 0x00 - ram[NMI_vector + 1] = 0x30 + ram[Cpu6502.RESET_vector] = 0x00 + ram[Cpu6502.RESET_vector + 1] = 0x10 + ram[Cpu6502.IRQ_vector] = 0x00 + ram[Cpu6502.IRQ_vector + 1] = 0x20 + ram[Cpu6502.NMI_vector] = 0x00 + ram[Cpu6502.NMI_vector + 1] = 0x30 // // read the RTC and write the date+time to $2000 // for(b in listOf(0xa0, 0x00, 0xb9, 0x00, 0xd1, 0x99, 0x00, 0x20, 0xc8, 0xc0, 0x09, 0xd0, 0xf5, 0x00).withIndex()) { @@ -63,7 +57,7 @@ private fun startSimulator(args: Array) { bus.add(ram) bus.reset() - cpu.Status.I = false // enable interrupts + cpu.regP.I = false // enable interrupts // TODO // try { diff --git a/src/main/resources/version.properties b/src/main/resources/version.properties new file mode 100644 index 0000000..e566b49 --- /dev/null +++ b/src/main/resources/version.properties @@ -0,0 +1 @@ +version=1.0 diff --git a/src/main/resources/version.txt b/src/main/resources/version.txt deleted file mode 100644 index d3827e7..0000000 --- a/src/main/resources/version.txt +++ /dev/null @@ -1 +0,0 @@ -1.0 diff --git a/src/test/kotlin/C64KernalStubs.kt b/src/test/kotlin/C64KernalStubs.kt index c5fd9bc..695c427 100644 --- a/src/test/kotlin/C64KernalStubs.kt +++ b/src/test/kotlin/C64KernalStubs.kt @@ -1,5 +1,5 @@ import razorvine.ksim65.components.Address -import razorvine.ksim65.components.Cpu6502 +import razorvine.ksim65.Cpu6502 import razorvine.ksim65.components.Ram @@ -10,7 +10,7 @@ class C64KernalStubs(private val ram: Ram) { 0xffd2 -> { // CHROUT ram[0x030c] = 0 - val char = cpu.A.toChar() + val char = cpu.regA.toChar() if(char==13.toChar()) println() else if(char in ' '..'~') diff --git a/src/test/kotlin/FunctionalTestsBase.kt b/src/test/kotlin/FunctionalTestsBase.kt index aa3b40c..9c56a36 100644 --- a/src/test/kotlin/FunctionalTestsBase.kt +++ b/src/test/kotlin/FunctionalTestsBase.kt @@ -1,5 +1,5 @@ -import razorvine.ksim65.components.Bus -import razorvine.ksim65.components.Cpu6502 +import razorvine.ksim65.Bus +import razorvine.ksim65.Cpu6502 import razorvine.ksim65.components.Ram import kotlin.test.* @@ -44,8 +44,8 @@ abstract class FunctionalTestsBase { protected fun runTest(testprogram: String) { ram.loadPrg("src/test/kotlin/6502testsuite/$testprogram") bus.reset() - cpu.SP = 0xfd - cpu.Status.fromByte(0b00100100) + cpu.regSP = 0xfd + cpu.regP.fromByte(0b00100100) try { while (cpu.totalCycles < 50000000L) { bus.clock() diff --git a/src/test/kotlin/Test6502.kt b/src/test/kotlin/Test6502.kt index e40aeab..083cfb4 100644 --- a/src/test/kotlin/Test6502.kt +++ b/src/test/kotlin/Test6502.kt @@ -1,4 +1,4 @@ -import razorvine.ksim65.components.Cpu6502 +import razorvine.ksim65.Cpu6502 import org.junit.jupiter.api.TestInstance import kotlin.test.* @@ -48,8 +48,8 @@ class Test6502 : TestCommon6502() { @Test fun test_adc_ind_indexed_has_page_wrap_bug() { - mpu.A = 0x01 - mpu.X = 0xFF + mpu.regA = 0x01 + mpu.regX = 0xFF // $0000 ADC ($80,X) // $007f Vector to $BBBB (read if page wrapped) // $017f Vector to $ABCD (read if no page wrap) @@ -59,16 +59,16 @@ class Test6502 : TestCommon6502() { memory[0xABCD] = 0x01 memory[0xBBBB] = 0x02 mpu.step() - assertEquals(0x03, mpu.A) + assertEquals(0x03, mpu.regA) } // ADC Indexed, Indirect (Y) @Test fun test_adc_indexed_ind_y_has_page_wrap_bug() { - mpu.PC = 0x1000 - mpu.A = 0x42 - mpu.Y = 0x02 + mpu.regPC = 0x1000 + mpu.regA = 0x42 + mpu.regY = 0x02 // $1000 ADC ($FF),Y writeMem(memory, 0x1000, listOf(0x71, 0xff)) // Vector @@ -79,30 +79,30 @@ class Test6502 : TestCommon6502() { memory[0x2012] = 0x14 // read if no page wrap memory[0x0012] = 0x42 // read if page wrapped mpu.step() - assertEquals(0x84, mpu.A) + assertEquals(0x84, mpu.regA) } // LDA Zero Page, X-Indexed @Test fun test_lda_zp_x_indexed_page_wraps() { - mpu.A = 0x00 - mpu.X = 0xFF + mpu.regA = 0x00 + mpu.regX = 0xFF // $0000 LDA $80,X writeMem(memory, 0x0000, listOf(0xB5, 0x80)) memory[0x007F] = 0x42 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x42, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x42, mpu.regA) } // AND Indexed, Indirect (Y) @Test fun test_and_indexed_ind_y_has_page_wrap_bug() { - mpu.PC = 0x1000 - mpu.A = 0x42 - mpu.Y = 0x02 + mpu.regPC = 0x1000 + mpu.regA = 0x42 + mpu.regY = 0x02 // $1000 AND ($FF),Y writeMem(memory, 0x1000, listOf(0x31, 0xff)) // Vector @@ -113,38 +113,38 @@ class Test6502 : TestCommon6502() { memory[0x2012] = 0x00 // read if no page wrap memory[0x0012] = 0xFF // read if page wrapped mpu.step() - assertEquals(0x42, mpu.A) + assertEquals(0x42, mpu.regA) } // BRK @Test fun test_brk_preserves_decimal_flag_when_it_is_set() { - mpu.Status.D = true + mpu.regP.D = true // $C000 BRK memory[0xC000] = 0x00 - mpu.PC = 0xC000 + mpu.regPC = 0xC000 mpu.step() - assertTrue(mpu.Status.B) - assertTrue(mpu.Status.D) + assertTrue(mpu.regP.B) + assertTrue(mpu.regP.D) } @Test fun test_brk_preserves_decimal_flag_when_it_is_clear() { // $C000 BRK memory[0xC000] = 0x00 - mpu.PC = 0xC000 + mpu.regPC = 0xC000 mpu.step() - assertTrue(mpu.Status.B) - assertFalse(mpu.Status.D) + assertTrue(mpu.regP.B) + assertFalse(mpu.regP.D) } // CMP Indirect, Indexed (X) @Test fun test_cmp_ind_x_has_page_wrap_bug() { - mpu.A = 0x42 - mpu.X = 0xFF + mpu.regA = 0x42 + mpu.regX = 0xFF // $0000 CMP ($80,X) // $007f Vector to $BBBB (read if page wrapped) // $017f Vector to $ABCD (read if no page wrap) @@ -154,16 +154,16 @@ class Test6502 : TestCommon6502() { memory[0xABCD] = 0x00 memory[0xBBBB] = 0x42 mpu.step() - assertTrue(mpu.Status.Z) + assertTrue(mpu.regP.Z) } // CMP Indexed, Indirect (Y) @Test fun test_cmp_indexed_ind_y_has_page_wrap_bug() { - mpu.PC = 0x1000 - mpu.A = 0x42 - mpu.Y = 0x02 + mpu.regPC = 0x1000 + mpu.regA = 0x42 + mpu.regY = 0x02 // $1000 CMP ($FF),Y writeMem(memory, 0x1000, listOf(0xd1, 0xff)) // Vector @@ -174,15 +174,15 @@ class Test6502 : TestCommon6502() { memory[0x2012] = 0x14 // read if no page wrap memory[0x0012] = 0x42 // read if page wrapped mpu.step() - assertTrue(mpu.Status.Z) + assertTrue(mpu.regP.Z) } // EOR Indirect, Indexed (X) @Test fun test_eor_ind_x_has_page_wrap_bug() { - mpu.A = 0xAA - mpu.X = 0xFF + mpu.regA = 0xAA + mpu.regX = 0xFF // $0000 EOR ($80,X) // $007f Vector to $BBBB (read if page wrapped) // $017f Vector to $ABCD (read if no page wrap) @@ -192,16 +192,16 @@ class Test6502 : TestCommon6502() { memory[0xABCD] = 0x00 memory[0xBBBB] = 0xFF mpu.step() - assertEquals(0x55, mpu.A) + assertEquals(0x55, mpu.regA) } // EOR Indexed, Indirect (Y) @Test fun test_eor_indexed_ind_y_has_page_wrap_bug() { - mpu.PC = 0x1000 - mpu.A = 0xAA - mpu.Y = 0x02 + mpu.regPC = 0x1000 + mpu.regA = 0xAA + mpu.regY = 0x02 // $1000 EOR ($FF),Y writeMem(memory, 0x1000, listOf(0x51, 0xff)) // Vector @@ -212,15 +212,15 @@ class Test6502 : TestCommon6502() { memory[0x2012] = 0x00 // read if no page wrap memory[0x0012] = 0xFF // read if page wrapped mpu.step() - assertEquals(0x55, mpu.A) + assertEquals(0x55, mpu.regA) } // LDA Indirect, Indexed (X) @Test fun test_lda_ind_indexed_x_has_page_wrap_bug() { - mpu.A = 0x00 - mpu.X = 0xff + mpu.regA = 0x00 + mpu.regX = 0xff // $0000 LDA ($80,X) // $007f Vector to $BBBB (read if page wrapped) // $017f Vector to $ABCD (read if no page wrap) @@ -230,16 +230,16 @@ class Test6502 : TestCommon6502() { memory[0xABCD] = 0x42 memory[0xBBBB] = 0xEF mpu.step() - assertEquals(0xEF, mpu.A) + assertEquals(0xEF, mpu.regA) } // LDA Indexed, Indirect (Y) @Test fun test_lda_indexed_ind_y_has_page_wrap_bug() { - mpu.PC = 0x1000 - mpu.A = 0x00 - mpu.Y = 0x02 + mpu.regPC = 0x1000 + mpu.regA = 0x00 + mpu.regY = 0x02 // $1000 LDA ($FF),Y writeMem(memory, 0x1000, listOf(0xb1, 0xff)) // Vector @@ -250,21 +250,21 @@ class Test6502 : TestCommon6502() { memory[0x2012] = 0x14 // read if no page wrap memory[0x0012] = 0x42 // read if page wrapped mpu.step() - assertEquals(0x42, mpu.A) + assertEquals(0x42, mpu.regA) } // LDA Zero Page, X-Indexed @Test fun test_lda_zp_x_has_page_wrap_bug() { - mpu.A = 0x00 - mpu.X = 0xFF + mpu.regA = 0x00 + mpu.regX = 0xFF // $0000 LDA $80,X writeMem(memory, 0x0000, listOf(0xB5, 0x80)) memory[0x007F] = 0x42 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x42, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x42, mpu.regA) } // JMP Indirect @@ -275,7 +275,7 @@ class Test6502 : TestCommon6502() { // $0000 JMP ($00) writeMem(memory, 0, listOf(0x6c, 0xff, 0x00)) mpu.step() - assertEquals(0x6c00, mpu.PC) + assertEquals(0x6c00, mpu.regPC) assertEquals((5+ Cpu6502.resetCycles).toLong(), mpu.totalCycles) } @@ -283,9 +283,9 @@ class Test6502 : TestCommon6502() { @Test fun test_ora_indexed_ind_y_has_page_wrap_bug() { - mpu.PC = 0x1000 - mpu.A = 0x00 - mpu.Y = 0x02 + mpu.regPC = 0x1000 + mpu.regA = 0x00 + mpu.regY = 0x02 // $1000 ORA ($FF),Y writeMem(memory, 0x1000, listOf(0x11, 0xff)) // Vector @@ -296,7 +296,7 @@ class Test6502 : TestCommon6502() { memory[0x2012] = 0x00 // read if no page wrap memory[0x0012] = 0x42 // read if page wrapped mpu.step() - assertEquals(0x42, mpu.A) + assertEquals(0x42, mpu.regA) } // SBC Indexed, Indirect (Y) @@ -304,10 +304,10 @@ class Test6502 : TestCommon6502() { @Test fun test_sbc_indexed_ind_y_has_page_wrap_bug() { - mpu.PC = 0x1000 - mpu.Status.C = true - mpu.A = 0x42 - mpu.Y = 0x02 + mpu.regPC = 0x1000 + mpu.regP.C = true + mpu.regA = 0x42 + mpu.regY = 0x02 // $1000 SBC ($FF),Y writeMem(memory, 0x1000, listOf(0xf1, 0xff)) // Vector @@ -318,44 +318,44 @@ class Test6502 : TestCommon6502() { memory[0x2012] = 0x02 // read if no page wrap memory[0x0012] = 0x03 // read if page wrapped mpu.step() - assertEquals(0x3f, mpu.A) + assertEquals(0x3f, mpu.regA) } @Test fun test_sbc_bcd_on_immediate_20_minus_0a_carry_unset() { - mpu.Status.D = true - mpu.Status.C = false - mpu.A = 0x20 + mpu.regP.D = true + mpu.regP.C = false + mpu.regA = 0x20 // $0000 SBC #$0a writeMem(memory, 0x0000, listOf(0xe9, 0x0a)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x1f, mpu.A) // 0x1f on 6502, 0x0f on 65c02 - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.V) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x1f, mpu.regA) // 0x1f on 6502, 0x0f on 65c02 + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.C) + assertFalse(mpu.regP.N) + assertFalse(mpu.regP.V) } @Test fun test_adc_bcd_on_immediate_9c_plus_9d() { - mpu.Status.D = true - mpu.Status.C = false - mpu.Status.N = true - mpu.A = 0x9c + mpu.regP.D = true + mpu.regP.C = false + mpu.regP.N = true + mpu.regA = 0x9c // $0000 ADC #$9d // $0002 ADC #$9d writeMem(memory, 0x0000, listOf(0x69, 0x9d)) writeMem(memory, 0x0002, listOf(0x69, 0x9d)) mpu.step() - assertEquals(0x9f, mpu.A) - assertTrue(mpu.Status.C) + assertEquals(0x9f, mpu.regA) + assertTrue(mpu.regP.C) mpu.step() - assertEquals(0x0004, mpu.PC) - assertEquals(0x93, mpu.A) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.N) // False on 6502, True on 65C02 + assertEquals(0x0004, mpu.regPC) + assertEquals(0x93, mpu.regA) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.C) + assertTrue(mpu.regP.V) + assertFalse(mpu.regP.N) // False on 6502, True on 65C02 } } diff --git a/src/test/kotlin/Test6502CpuBasics.kt b/src/test/kotlin/Test6502CpuBasics.kt index 9a30d47..082081a 100644 --- a/src/test/kotlin/Test6502CpuBasics.kt +++ b/src/test/kotlin/Test6502CpuBasics.kt @@ -1,6 +1,6 @@ -import razorvine.ksim65.components.Bus -import razorvine.ksim65.components.Cpu6502 -import razorvine.ksim65.components.Cpu65C02 +import razorvine.ksim65.Bus +import razorvine.ksim65.Cpu6502 +import razorvine.ksim65.Cpu65C02 import razorvine.ksim65.components.Ram import kotlin.test.* import kotlin.system.measureNanoTime @@ -15,16 +15,16 @@ class Test6502CpuBasics { val bus = Bus() bus.add(cpu) cpu.reset() - assertEquals(0xfd, cpu.SP) - assertEquals(0xffff, cpu.PC) + assertEquals(0xfd, cpu.regSP) + assertEquals(0xffff, cpu.regPC) assertEquals(0, cpu.totalCycles) assertEquals(8, cpu.instrCycles) - assertEquals(0, cpu.A) - assertEquals(0, cpu.X) - assertEquals(0, cpu.Y) + assertEquals(0, cpu.regA) + assertEquals(0, cpu.regX) + assertEquals(0, cpu.regY) assertEquals(0, cpu.currentOpcode) - assertEquals(Cpu6502.StatusRegister(C = false, Z = false, I = true, D = false, B = false, V = false, N = false), cpu.Status) - assertEquals(0b00100100, cpu.Status.asByte()) + assertEquals(Cpu6502.StatusRegister(C = false, Z = false, I = true, D = false, B = false, V = false, N = false), cpu.regP) + assertEquals(0b00100100, cpu.regP.asByte()) } @Test @@ -33,16 +33,16 @@ class Test6502CpuBasics { val bus = Bus() bus.add(cpu) cpu.reset() - assertEquals(0xfd, cpu.SP) - assertEquals(0xffff, cpu.PC) + assertEquals(0xfd, cpu.regSP) + assertEquals(0xffff, cpu.regPC) assertEquals(0, cpu.totalCycles) assertEquals(8, cpu.instrCycles) - assertEquals(0, cpu.A) - assertEquals(0, cpu.X) - assertEquals(0, cpu.Y) + assertEquals(0, cpu.regA) + assertEquals(0, cpu.regX) + assertEquals(0, cpu.regY) assertEquals(0, cpu.currentOpcode) - assertEquals(Cpu6502.StatusRegister(C = false, Z = false, I = true, D = false, B = false, V = false, N = false), cpu.Status) - assertEquals(0b00100100, cpu.Status.asByte()) + assertEquals(Cpu6502.StatusRegister(C = false, Z = false, I = true, D = false, B = false, V = false, N = false), cpu.regP) + assertEquals(0b00100100, cpu.regP.asByte()) } @Test @@ -58,7 +58,7 @@ class Test6502CpuBasics { bus.add(cpu) bus.add(ram) cpu.reset() - cpu.PC = 0x1000 + cpu.regPC = 0x1000 // warmup while(cpu.totalCycles<5000000) @@ -90,7 +90,7 @@ class Test6502CpuBasics { bus.add(cpu) bus.add(ram) cpu.reset() - cpu.PC = 0x1000 + cpu.regPC = 0x1000 // warmup while(cpu.totalCycles<5000000) diff --git a/src/test/kotlin/Test6502Functional.kt b/src/test/kotlin/Test6502Functional.kt index 9297d9c..10a2520 100644 --- a/src/test/kotlin/Test6502Functional.kt +++ b/src/test/kotlin/Test6502Functional.kt @@ -1,7 +1,7 @@ -import razorvine.ksim65.components.Bus +import razorvine.ksim65.Bus import razorvine.ksim65.components.Ram -import razorvine.ksim65.components.Cpu6502 -import razorvine.ksim65.components.Cpu65C02 +import razorvine.ksim65.Cpu6502 +import razorvine.ksim65.Cpu65C02 import java.lang.Exception import kotlin.test.* @@ -19,7 +19,7 @@ class Test6502Functional { bus.add(cpu) bus.add(ram) cpu.reset() - cpu.PC = 0x0400 + cpu.regPC = 0x0400 cpu.addBreakpoint(0x3469) { _, _ -> // reaching this address means successful test result if(cpu.currentOpcode==0x4c) @@ -37,7 +37,7 @@ class Test6502Functional { } println(cpu.logState()) - val d = cpu.disassemble(ram, cpu.PC-20, cpu.PC+20) + val d = cpu.disassemble(ram, cpu.regPC-20, cpu.regPC+20) println(d.joinToString ("\n")) fail("test failed") } @@ -51,7 +51,7 @@ class Test6502Functional { bus.add(cpu) bus.add(ram) cpu.reset() - cpu.PC = 0x0400 + cpu.regPC = 0x0400 cpu.addBreakpoint(0x24f1) { _, _ -> // reaching this address means successful test result if(cpu.currentOpcode==0x4c) @@ -69,7 +69,7 @@ class Test6502Functional { } println(cpu.logState()) - val d = cpu.disassemble(ram, cpu.PC-20, cpu.PC+20) + val d = cpu.disassemble(ram, cpu.regPC-20, cpu.regPC+20) println(d.joinToString ("\n")) fail("test failed") } diff --git a/src/test/kotlin/Test65C02.kt b/src/test/kotlin/Test65C02.kt index 7c83f95..77e1eb8 100644 --- a/src/test/kotlin/Test65C02.kt +++ b/src/test/kotlin/Test65C02.kt @@ -1,4 +1,4 @@ -import razorvine.ksim65.components.Cpu65C02 +import razorvine.ksim65.Cpu65C02 import org.junit.jupiter.api.TestInstance import kotlin.test.* @@ -48,540 +48,540 @@ class Test65C02 : TestCommon6502() { fun test_reset_clears_decimal_flag() { // W65C02S Datasheet, Apr 14 2009, Table 7-1 Operational Enhancements // NMOS 6502 decimal flag = indetermine after reset, CMOS 65C02 = 0 - mpu.Status.D = true + mpu.regP.D = true mpu.reset() - assertFalse(mpu.Status.D) + assertFalse(mpu.regP.D) } // ADC Zero Page, Indirect @Test fun test_adc_bcd_off_zp_ind_carry_clear_in_accumulator_zeroes() { - mpu.A = 0x00 + mpu.regA = 0x00 // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + assertEquals(0x00, mpu.regA) + assertFalse(mpu.regP.C) + assertFalse(mpu.regP.N) + assertTrue(mpu.regP.Z) } @Test fun test_adc_bcd_off_zp_ind_carry_set_in_accumulator_zero() { - mpu.A = 0 - mpu.Status.C = true + mpu.regA = 0 + mpu.regP.C = true // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + assertEquals(0x01, mpu.regA) + assertFalse(mpu.regP.N) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.C) } @Test fun test_adc_bcd_off_zp_ind_carry_clear_in_no_carry_clear_out() { - mpu.A = 0x01 + mpu.regA = 0x01 // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0xFE mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + assertEquals(0xFF, mpu.regA) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.C) + assertFalse(mpu.regP.Z) } @Test fun test_adc_bcd_off_zp_ind_carry_clear_in_carry_set_out() { - mpu.A = 0x02 + mpu.regA = 0x02 // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertEquals(0x01, mpu.regA) + assertTrue(mpu.regP.C) + assertFalse(mpu.regP.N) + assertFalse(mpu.regP.Z) } @Test fun test_adc_bcd_off_zp_ind_overflow_cleared_no_carry_01_plus_01() { - mpu.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x02, mpu.regA) + assertFalse(mpu.regP.V) } @Test fun test_adc_bcd_off_zp_ind_overflow_cleared_no_carry_01_plus_ff() { - mpu.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, mpu.regA) + assertFalse(mpu.regP.V) } @Test fun test_adc_bcd_off_zp_ind_overflow_set_no_carry_7f_plus_01() { - mpu.Status.C = false - mpu.A = 0x7f + mpu.regP.C = false + mpu.regA = 0x7f // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x80, mpu.regA) + assertTrue(mpu.regP.V) } @Test fun test_adc_bcd_off_zp_ind_overflow_set_no_carry_80_plus_ff() { - mpu.Status.C = false - mpu.A = 0x80 + mpu.regP.C = false + mpu.regA = 0x80 // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x7f, mpu.regA) + assertTrue(mpu.regP.V) } @Test fun test_adc_bcd_off_zp_ind_overflow_set_on_40_plus_40() { - mpu.A = 0x40 + mpu.regA = 0x40 // $0000 ADC ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x72, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x40 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x80, mpu.regA) + assertTrue(mpu.regP.N) + assertTrue(mpu.regP.V) + assertFalse(mpu.regP.Z) } // AND Zero Page, Indirect @Test fun test_and_zp_ind_all_zeros_setting_zero_flag() { - mpu.A = 0xFF + mpu.regA = 0xFF // $0000 AND ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x32, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_and_zp_ind_zeros_and_ones_setting_negative_flag() { - mpu.A = 0xFF + mpu.regA = 0xFF // $0000 AND ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x32, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0xAA mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertEquals(0xAA, mpu.regA) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } // BIT (Absolute, X-Indexed) @Test fun test_bit_abs_x_copies_bit_7_of_memory_to_n_flag_when_0() { - mpu.Status.N = false - mpu.X = 0x02 + mpu.regP.N = false + mpu.regX = 0x02 // $0000 BIT $FEEB,X writeMem(memory, 0x0000, listOf(0x3C, 0xEB, 0xFE)) memory[0xFEED] = 0xFF - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertTrue(mpu.Status.N) + assertTrue(mpu.regP.N) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) } @Test fun test_bit_abs_x_copies_bit_7_of_memory_to_n_flag_when_1() { - mpu.Status.N = true - mpu.X = 0x02 + mpu.regP.N = true + mpu.regX = 0x02 // $0000 BIT $FEEB,X writeMem(memory, 0x0000, listOf(0x3C, 0xEB, 0xFE)) memory[0xFEED] = 0x00 - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertFalse(mpu.Status.N) + assertFalse(mpu.regP.N) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) } @Test fun test_bit_abs_x_copies_bit_6_of_memory_to_v_flag_when_0() { - mpu.Status.V = false - mpu.X = 0x02 + mpu.regP.V = false + mpu.regX = 0x02 // $0000 BIT $FEEB,X writeMem(memory, 0x0000, listOf(0x3C, 0xEB, 0xFE)) memory[0xFEED] = 0xFF - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertTrue(mpu.Status.V) + assertTrue(mpu.regP.V) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) } @Test fun test_bit_abs_x_copies_bit_6_of_memory_to_v_flag_when_1() { - mpu.Status.V = true - mpu.X = 0x02 + mpu.regP.V = true + mpu.regX = 0x02 // $0000 BIT $FEEB,X writeMem(memory, 0x0000, listOf(0x3C, 0xEB, 0xFE)) memory[0xFEED] = 0x00 - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertFalse(mpu.Status.V) + assertFalse(mpu.regP.V) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) } @Test fun test_bit_abs_x_stores_result_of_and_in_z_preserves_a_when_1() { - mpu.Status.Z = false - mpu.X = 0x02 + mpu.regP.Z = false + mpu.regX = 0x02 // $0000 BIT $FEEB,X writeMem(memory, 0x0000, listOf(0x3C, 0xEB, 0xFE)) memory[0xFEED] = 0x00 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertTrue(mpu.Status.Z) - assertEquals(0x01, mpu.A) + assertTrue(mpu.regP.Z) + assertEquals(0x01, mpu.regA) assertEquals(0x00, memory[0xFEED]) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) } @Test fun test_bit_abs_x_stores_result_of_and_nonzero_in_z_preserves_a() { - mpu.Status.Z = true - mpu.X = 0x02 + mpu.regP.Z = true + mpu.regX = 0x02 // $0000 BIT $FEEB,X writeMem(memory, 0x0000, listOf(0x3C, 0xEB, 0xFE)) memory[0xFEED] = 0x01 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertFalse(mpu.Status.Z) // result of AND is non-zero - assertEquals(0x01, mpu.A) + assertFalse(mpu.regP.Z) // result of AND is non-zero + assertEquals(0x01, mpu.regA) assertEquals(0x01, memory[0xFEED]) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) } @Test fun test_bit_abs_x_stores_result_of_and_when_zero_in_z_preserves_a() { - mpu.Status.Z = false - mpu.X = 0x02 + mpu.regP.Z = false + mpu.regX = 0x02 // $0000 BIT $FEEB,X writeMem(memory, 0x0000, listOf(0x3C, 0xEB, 0xFE)) memory[0xFEED] = 0x00 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertTrue(mpu.Status.Z) // result of AND is zero - assertEquals(0x01, mpu.A) + assertTrue(mpu.regP.Z) // result of AND is zero + assertEquals(0x01, mpu.regA) assertEquals(0x00, memory[0xFEED]) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) } // BIT (Immediate) @Test fun test_bit_imm_does_not_affect_n_and_z_flags() { - mpu.Status.N = true - mpu.Status.V = true + mpu.regP.N = true + mpu.regP.V = true // $0000 BIT #$FF writeMem(memory, 0x0000, listOf(0x89, 0xff)) - mpu.A = 0x00 + mpu.regA = 0x00 mpu.step() - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertEquals(0x00, mpu.A) + assertTrue(mpu.regP.N) + assertTrue(mpu.regP.V) + assertEquals(0x00, mpu.regA) assertEquals(2 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x02, mpu.PC) + assertEquals(0x02, mpu.regPC) } @Test fun test_bit_imm_stores_result_of_and_in_z_preserves_a_when_1() { - mpu.Status.Z = false + mpu.regP.Z = false // $0000 BIT #$00 writeMem(memory, 0x0000, listOf(0x89, 0x00)) - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertTrue(mpu.Status.Z) - assertEquals(0x01, mpu.A) + assertTrue(mpu.regP.Z) + assertEquals(0x01, mpu.regA) assertEquals(2 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x02, mpu.PC) + assertEquals(0x02, mpu.regPC) } @Test fun test_bit_imm_stores_result_of_and_when_nonzero_in_z_preserves_a() { - mpu.Status.Z = true + mpu.regP.Z = true // $0000 BIT #$01 writeMem(memory, 0x0000, listOf(0x89, 0x01)) - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertFalse(mpu.Status.Z) // result of AND is non-zero - assertEquals(0x01, mpu.A) + assertFalse(mpu.regP.Z) // result of AND is non-zero + assertEquals(0x01, mpu.regA) assertEquals(2 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x02, mpu.PC) + assertEquals(0x02, mpu.regPC) } @Test fun test_bit_imm_stores_result_of_and_when_zero_in_z_preserves_a() { - mpu.Status.Z = false + mpu.regP.Z = false // $0000 BIT #$00 writeMem(memory, 0x0000, listOf(0x89, 0x00)) - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertTrue(mpu.Status.Z) // result of AND is zero - assertEquals(0x01, mpu.A) + assertTrue(mpu.regP.Z) // result of AND is zero + assertEquals(0x01, mpu.regA) assertEquals(2 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x02, mpu.PC) + assertEquals(0x02, mpu.regPC) } // BIT (Zero Page, X-Indexed) @Test fun test_bit_zp_x_copies_bit_7_of_memory_to_n_flag_when_0() { - mpu.Status.N = false + mpu.regP.N = false // $0000 BIT $0010,X writeMem(memory, 0x0000, listOf(0x34, 0x10)) memory[0x0013] = 0xFF - mpu.X = 0x03 - mpu.A = 0xFF + mpu.regX = 0x03 + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertTrue(mpu.Status.N) + assertTrue(mpu.regP.N) } @Test fun test_bit_zp_x_copies_bit_7_of_memory_to_n_flag_when_1() { - mpu.Status.N = true + mpu.regP.N = true // $0000 BIT $0010,X writeMem(memory, 0x0000, listOf(0x34, 0x10)) memory[0x0013] = 0x00 - mpu.X = 0x03 - mpu.A = 0xFF + mpu.regX = 0x03 + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertFalse(mpu.Status.N) + assertFalse(mpu.regP.N) } @Test fun test_bit_zp_x_copies_bit_6_of_memory_to_v_flag_when_0() { - mpu.Status.V = false + mpu.regP.V = false // $0000 BIT $0010,X writeMem(memory, 0x0000, listOf(0x34, 0x10)) memory[0x0013] = 0xFF - mpu.X = 0x03 - mpu.A = 0xFF + mpu.regX = 0x03 + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertTrue(mpu.Status.V) + assertTrue(mpu.regP.V) } @Test fun test_bit_zp_x_copies_bit_6_of_memory_to_v_flag_when_1() { - mpu.Status.V = true + mpu.regP.V = true // $0000 BIT $0010,X writeMem(memory, 0x0000, listOf(0x34, 0x10)) memory[0x0013] = 0x00 - mpu.X = 0x03 - mpu.A = 0xFF + mpu.regX = 0x03 + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertFalse(mpu.Status.V) + assertFalse(mpu.regP.V) } @Test fun test_bit_zp_x_stores_result_of_and_in_z_preserves_a_when_1() { - mpu.Status.Z = false + mpu.regP.Z = false // $0000 BIT $0010,X writeMem(memory, 0x0000, listOf(0x34, 0x10)) memory[0x0013] = 0x00 - mpu.X = 0x03 - mpu.A = 0x01 + mpu.regX = 0x03 + mpu.regA = 0x01 mpu.step() - assertTrue(mpu.Status.Z) - assertEquals(0x0002, mpu.PC) + assertTrue(mpu.regP.Z) + assertEquals(0x0002, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x01, mpu.A) - assertEquals(0x00, memory[0x0010 + mpu.X]) + assertEquals(0x01, mpu.regA) + assertEquals(0x00, memory[0x0010 + mpu.regX]) } @Test fun test_bit_zp_x_stores_result_of_and_when_nonzero_in_z_preserves_a() { - mpu.Status.Z = true + mpu.regP.Z = true // $0000 BIT $0010,X writeMem(memory, 0x0000, listOf(0x34, 0x10)) memory[0x0013] = 0x01 - mpu.X = 0x03 - mpu.A = 0x01 + mpu.regX = 0x03 + mpu.regA = 0x01 mpu.step() - assertFalse(mpu.Status.Z) // result of AND is non-zero - assertEquals(0x0002, mpu.PC) + assertFalse(mpu.regP.Z) // result of AND is non-zero + assertEquals(0x0002, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x01, mpu.A) - assertEquals(0x01, memory[0x0010 + mpu.X]) + assertEquals(0x01, mpu.regA) + assertEquals(0x01, memory[0x0010 + mpu.regX]) } @Test fun test_bit_zp_x_stores_result_of_and_when_zero_in_z_preserves_a() { - mpu.Status.Z = false + mpu.regP.Z = false // $0000 BIT $0010,X writeMem(memory, 0x0000, listOf(0x34, 0x10)) memory[0x0013] = 0x00 - mpu.X = 0x03 - mpu.A = 0x01 + mpu.regX = 0x03 + mpu.regA = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertTrue(mpu.Status.Z) // result of AND is zero - assertEquals(0x01, mpu.A) - assertEquals(0x00, memory[0x0010 + mpu.X]) + assertTrue(mpu.regP.Z) // result of AND is zero + assertEquals(0x01, mpu.regA) + assertEquals(0x00, memory[0x0010 + mpu.regX]) } // BRK @Test fun test_brk_clears_decimal_flag() { - mpu.Status.D = true + mpu.regP.D = true // $C000 BRK memory[0xC000] = 0x00 - mpu.PC = 0xC000 + mpu.regPC = 0xC000 mpu.step() - assertTrue(mpu.Status.B) - assertFalse(mpu.Status.D) + assertTrue(mpu.regP.B) + assertFalse(mpu.regP.D) } // CMP Zero Page, Indirect @Test fun test_cmp_zpi_sets_z_flag_if_equal() { - mpu.A = 0x42 + mpu.regA = 0x42 // $0000 AND ($10) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0xd2, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x42 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x42, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertEquals(0x42, mpu.regA) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_cmp_zpi_resets_z_flag_if_unequal() { - mpu.A = 0x43 + mpu.regA = 0x43 // $0000 AND ($10) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0xd2, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x42 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x43, mpu.A) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertEquals(0x43, mpu.regA) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.N) } // EOR Zero Page, Indirect @Test fun test_eor_zp_ind_flips_bits_over_setting_z_flag() { - mpu.A = 0xFF + mpu.regA = 0xFF // $0000 EOR ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x52, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x00, mpu.A) + assertEquals(0x00, mpu.regA) assertEquals(0xFF, memory[0xABCD]) - assertTrue(mpu.Status.Z) + assertTrue(mpu.regP.Z) } @Test fun test_eor_zp_ind_flips_bits_over_setting_n_flag() { - mpu.A = 0x00 + mpu.regA = 0x00 // $0000 EOR ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x52, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0xFF, mpu.A) + assertEquals(0xFF, mpu.regA) assertEquals(0xFF, memory[0xABCD]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } // INC Accumulator @@ -589,34 +589,34 @@ class Test65C02 : TestCommon6502() { @Test fun test_inc_acc_increments_accum() { memory[0x0000] = 0x1A - mpu.A = 0x42 + mpu.regA = 0x42 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x43, mpu.A) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x43, mpu.regA) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_inc_acc_increments_accum_rolls_over_and_sets_zero_flag() { memory[0x0000] = 0x1A - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_inc_acc_sets_negative_flag_when_incrementing_above_7F() { memory[0x0000] = 0x1A - mpu.A = 0x7F + mpu.regA = 0x7F mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.A) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x80, mpu.regA) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) } // JMP Indirect @@ -627,7 +627,7 @@ class Test65C02 : TestCommon6502() { // $0000 JMP ($10FF) writeMem(memory, 0, listOf(0x6c, 0xFF, 0x10)) mpu.step() - assertEquals(0xABCD, mpu.PC) + assertEquals(0xABCD, mpu.regPC) assertEquals(6 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -635,13 +635,13 @@ class Test65C02 : TestCommon6502() { @Test fun test_jmp_iax_jumps_to_address() { - mpu.X = 2 + mpu.regX = 2 // $0000 JMP ($ABCD,X) // $ABCF Vector to $1234 writeMem(memory, 0x0000, listOf(0x7C, 0xCD, 0xAB)) writeMem(memory, 0xABCF, listOf(0x34, 0x12)) mpu.step() - assertEquals(0x1234, mpu.PC) + assertEquals(0x1234, mpu.regPC) assertEquals(6 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -649,86 +649,86 @@ class Test65C02 : TestCommon6502() { @Test fun test_lda_zp_ind_loads_a_sets_n_flag() { - mpu.A = 0x00 + mpu.regA = 0x00 // $0000 LDA ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0xB2, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertEquals(0x80, mpu.regA) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } @Test fun test_lda_zp_ind_loads_a_sets_z_flag() { - mpu.A = 0x00 + mpu.regA = 0x00 // $0000 LDA ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0xB2, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } // ORA Zero Page, Indirect @Test fun test_ora_zp_ind_zeroes_or_zeros_sets_z_flag() { - mpu.Status.Z = false - mpu.A = 0x00 - mpu.Y = 0x12 // These should not affect the ORA - mpu.X = 0x34 + mpu.regP.Z = false + mpu.regA = 0x00 + mpu.regY = 0x12 // These should not affect the ORA + mpu.regX = 0x34 // $0000 ORA ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x12, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) } @Test fun test_ora_zp_ind_turns_bits_on_sets_n_flag() { - mpu.Status.N = false - mpu.A = 0x03 + mpu.regP.N = false + mpu.regA = 0x03 // $0000 ORA ($0010) // $0010 Vector to $ABCD writeMem(memory, 0x0000, listOf(0x12, 0x10)) writeMem(memory, 0x0010, listOf(0xCD, 0xAB)) memory[0xABCD] = 0x82 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertEquals(0x83, mpu.regA) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } // PHX @Test fun test_phx_pushes_x_and_updates_sp() { - mpu.X = 0xAB - mpu.SP = 0xff + mpu.regX = 0xAB + mpu.regSP = 0xff // $0000 PHX memory[0x0000] = 0xDA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.X) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regX) assertEquals(0xAB, memory[0x01FF]) - assertEquals(0xFE, mpu.SP) + assertEquals(0xFE, mpu.regSP) assertEquals(3 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -736,15 +736,15 @@ class Test65C02 : TestCommon6502() { @Test fun test_phy_pushes_y_and_updates_sp() { - mpu.Y = 0xAB - mpu.SP = 0xff + mpu.regY = 0xAB + mpu.regSP = 0xff // $0000 PHY memory[0x0000] = 0x5A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.Y) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regY) assertEquals(0xAB, memory[0x01FF]) - assertEquals(0xFE, mpu.SP) + assertEquals(0xFE, mpu.regSP) assertEquals(3 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -755,11 +755,11 @@ class Test65C02 : TestCommon6502() { // $0000 PLX memory[0x0000] = 0xFA memory[0x01FF] = 0xAB - mpu.SP = 0xFE + mpu.regSP = 0xFE mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.X) - assertEquals(0xFF, mpu.SP) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regX) + assertEquals(0xFF, mpu.regSP) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -770,11 +770,11 @@ class Test65C02 : TestCommon6502() { // $0000 PLY memory[0x0000] = 0x7A memory[0x01FF] = 0xAB - mpu.SP = 0xFE + mpu.regSP = 0xFE mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.Y) - assertEquals(0xFF, mpu.SP) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regY) + assertEquals(0xFF, mpu.regSP) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -786,7 +786,7 @@ class Test65C02 : TestCommon6502() { // $0000 RMB0 $43 writeMem(memory, 0x0000, listOf(0x07, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b11111110 assertEquals(expected, memory[0x0043].toInt()) @@ -798,9 +798,9 @@ class Test65C02 : TestCommon6502() { // $0000 RMB0 $43 writeMem(memory, 0x0000, listOf(0x07, 0x43)) val expected = 0b01110101 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // RMB1 @@ -811,7 +811,7 @@ class Test65C02 : TestCommon6502() { // $0000 RMB1 $43 writeMem(memory, 0x0000, listOf(0x17, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b11111101 assertEquals(expected, memory[0x0043].toInt()) @@ -823,9 +823,9 @@ class Test65C02 : TestCommon6502() { // $0000 RMB1 $43 writeMem(memory, 0x0000, listOf(0x17, 0x43)) val expected = 0b01110101 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // RMB2 @@ -836,7 +836,7 @@ class Test65C02 : TestCommon6502() { // $0000 RMB2 $43 writeMem(memory, 0x0000, listOf(0x27, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b11111011 assertEquals(expected, memory[0x0043].toInt()) @@ -849,9 +849,9 @@ class Test65C02 : TestCommon6502() { // $0000 RMB2 $43 writeMem(memory, 0x0000, listOf(0x27, 0x43)) val expected = 0b01110101 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // RMB3 @@ -862,7 +862,7 @@ class Test65C02 : TestCommon6502() { // $0000 RMB3 $43 writeMem(memory, 0x0000, listOf(0x37, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b11110111 assertEquals(expected, memory[0x0043].toInt()) @@ -874,9 +874,9 @@ class Test65C02 : TestCommon6502() { // $0000 RMB3 $43 writeMem(memory, 0x0000, listOf(0x37, 0x43)) val expected = 0b01110101 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // RMB4 @@ -887,7 +887,7 @@ class Test65C02 : TestCommon6502() { // $0000 RMB4 $43 writeMem(memory, 0x0000, listOf(0x47, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b11101111 assertEquals(expected, memory[0x0043].toInt()) @@ -899,9 +899,9 @@ class Test65C02 : TestCommon6502() { // $0000 RMB4 $43 writeMem(memory, 0x0000, listOf(0x47, 0x43)) val expected = 0b01110101 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // RMB5 @@ -912,7 +912,7 @@ class Test65C02 : TestCommon6502() { // $0000 RMB5 $43 writeMem(memory, 0x0000, listOf(0x57, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b11011111 assertEquals(expected, memory[0x0043].toInt()) @@ -924,9 +924,9 @@ class Test65C02 : TestCommon6502() { // $0000 RMB5 $43 writeMem(memory, 0x0000, listOf(0x57, 0x43)) val expected = 0b01110101 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // RMB6 @@ -937,7 +937,7 @@ class Test65C02 : TestCommon6502() { // $0000 RMB6 $43 writeMem(memory, 0x0000, listOf(0x67, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b10111111 assertEquals(expected, memory[0x0043].toInt()) @@ -949,9 +949,9 @@ class Test65C02 : TestCommon6502() { // $0000 RMB6 $43 writeMem(memory, 0x0000, listOf(0x67, 0x43)) val expected = 0b01110101 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // RMB7 @@ -962,7 +962,7 @@ class Test65C02 : TestCommon6502() { // $0000 RMB7 $43 writeMem(memory, 0x0000, listOf(0x77, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b01111111 assertEquals(expected, memory[0x0043].toInt()) @@ -975,9 +975,9 @@ class Test65C02 : TestCommon6502() { // $0000 RMB7 $43 writeMem(memory, 0x0000, listOf(0x77, 0x43)) val expected = 0b01110101 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // STA Zero Page, Indirect @@ -985,37 +985,37 @@ class Test65C02 : TestCommon6502() { @Test fun test_sta_zp_ind_stores_a_leaves_a_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.A = 0xFF + mpu.regP.fromByte(flags) + mpu.regA = 0xFF // $0000 STA ($0010) // $0010 Vector to $FEED writeMem(memory, 0x0000, listOf(0x92, 0x10)) writeMem(memory, 0x0010, listOf(0xED, 0xFE)) memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) assertEquals(0xFF, memory[0xFEED]) - assertEquals(0xFF, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0xFF, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sta_zp_ind_stores_a_leaves_a_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.A = 0x00 + mpu.regP.fromByte(flags) + mpu.regA = 0x00 // $0000 STA ($0010) // $0010 Vector to $FEED writeMem(memory, 0x0000, listOf(0x92, 0x10)) writeMem(memory, 0x0010, listOf(0xED, 0xFE)) memory[0xFEED] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) assertEquals(0x00, memory[0xFEED]) - assertEquals(0x00, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x00, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } // SMB0 @@ -1026,7 +1026,7 @@ class Test65C02 : TestCommon6502() { // $0000 SMB0 $43 writeMem(memory, 0x0000, listOf(0x87, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b00000001 assertEquals(expected, memory[0x0043].toInt()) @@ -1038,9 +1038,9 @@ class Test65C02 : TestCommon6502() { // $0000 SMB0 $43 writeMem(memory, 0x0000, listOf(0x87, 0x43)) val expected = 0b11101100 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // SMB1 @@ -1051,7 +1051,7 @@ class Test65C02 : TestCommon6502() { // $0000 SMB1 $43 writeMem(memory, 0x0000, listOf(0x97, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b00000010 assertEquals(expected, memory[0x0043].toInt()) @@ -1063,9 +1063,9 @@ class Test65C02 : TestCommon6502() { // $0000 SMB1 $43 writeMem(memory, 0x0000, listOf(0x97, 0x43)) val expected = 0b11101100 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // SMB2 @@ -1076,7 +1076,7 @@ class Test65C02 : TestCommon6502() { // $0000 SMB2 $43 writeMem(memory, 0x0000, listOf(0xA7, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b00000100 assertEquals(expected, memory[0x0043].toInt()) @@ -1089,9 +1089,9 @@ class Test65C02 : TestCommon6502() { // $0000 SMB2 $43 writeMem(memory, 0x0000, listOf(0xA7, 0x43)) val expected = 0b11101100 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // SMB3 @@ -1102,7 +1102,7 @@ class Test65C02 : TestCommon6502() { // $0000 SMB3 $43 writeMem(memory, 0x0000, listOf(0xB7, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b00001000 assertEquals(expected, memory[0x0043].toInt()) @@ -1115,9 +1115,9 @@ class Test65C02 : TestCommon6502() { // $0000 SMB3 $43 writeMem(memory, 0x0000, listOf(0xB7, 0x43)) val expected = 0b11101100 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // SMB4 @@ -1128,7 +1128,7 @@ class Test65C02 : TestCommon6502() { // $0000 SMB4 $43 writeMem(memory, 0x0000, listOf(0xC7, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b00010000 assertEquals(expected, memory[0x0043].toInt()) @@ -1141,9 +1141,9 @@ class Test65C02 : TestCommon6502() { // $0000 SMB4 $43 writeMem(memory, 0x0000, listOf(0xC7, 0x43)) val expected = 0b11101100 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // SMB5 @@ -1154,7 +1154,7 @@ class Test65C02 : TestCommon6502() { // $0000 SMB5 $43 writeMem(memory, 0x0000, listOf(0xD7, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b00100000 assertEquals(expected, memory[0x0043].toInt()) @@ -1166,9 +1166,9 @@ class Test65C02 : TestCommon6502() { // $0000 SMB5 $43 writeMem(memory, 0x0000, listOf(0xD7, 0x43)) val expected = 0b11101100 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // SMB6 @@ -1179,7 +1179,7 @@ class Test65C02 : TestCommon6502() { // $0000 SMB6 $43 writeMem(memory, 0x0000, listOf(0xE7, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b01000000 assertEquals(expected, memory[0x0043].toInt()) @@ -1191,9 +1191,9 @@ class Test65C02 : TestCommon6502() { // $0000 SMB6 $43 writeMem(memory, 0x0000, listOf(0xE7, 0x43)) val expected = 0b11101100 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // SMB7 @@ -1204,7 +1204,7 @@ class Test65C02 : TestCommon6502() { // $0000 SMB7 $43 writeMem(memory, 0x0000, listOf(0xF7, 0x43)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) val expected = 0b10000000 assertEquals(expected, memory[0x0043].toInt()) @@ -1216,87 +1216,87 @@ class Test65C02 : TestCommon6502() { // $0000 SMB7 $43 writeMem(memory, 0x0000, listOf(0xF7, 0x43)) val expected = 0b11101100 - mpu.Status.fromByte(expected) + mpu.regP.fromByte(expected) mpu.step() - assertEquals(expected, mpu.Status.asByte().toInt()) + assertEquals(expected, mpu.regP.asByte().toInt()) } // SBC Zero Page, Indirect @Test fun test_sbc_zp_ind_all_zeros_and_no_borrow_is_zero() { - mpu.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 + mpu.regP.D = false + mpu.regP.C = true // borrow = 0 + mpu.regA = 0x00 // $0000 SBC ($10) // $0010 Vector to $FEED writeMem(memory, 0x0000, listOf(0xF2, 0x10)) writeMem(memory, 0x0010, listOf(0xED, 0xFE)) memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + assertEquals(0x00, mpu.regA) + assertFalse(mpu.regP.N) + assertTrue(mpu.regP.C) + assertTrue(mpu.regP.Z) } @Test fun test_sbc_zp_ind_downto_zero_no_borrow_sets_z_clears_n() { - mpu.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + mpu.regP.D = false + mpu.regP.C = true // borrow = 0 + mpu.regA = 0x01 // $0000 SBC ($10) // $0010 Vector to $FEED writeMem(memory, 0x0000, listOf(0xF2, 0x10)) writeMem(memory, 0x0010, listOf(0xED, 0xFE)) memory[0xFEED] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + assertEquals(0x00, mpu.regA) + assertFalse(mpu.regP.N) + assertTrue(mpu.regP.C) + assertTrue(mpu.regP.Z) } @Test fun test_sbc_zp_ind_downto_zero_with_borrow_sets_z_clears_n() { - mpu.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + mpu.regP.D = false + mpu.regP.C = false // borrow = 1 + mpu.regA = 0x01 // $0000 SBC ($10) // $0010 Vector to $FEED writeMem(memory, 0x0000, listOf(0xF2, 0x10)) writeMem(memory, 0x0010, listOf(0xED, 0xFE)) memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + assertEquals(0x00, mpu.regA) + assertFalse(mpu.regP.N) + assertTrue(mpu.regP.C) + assertTrue(mpu.regP.Z) } @Test fun test_sbc_zp_ind_downto_four_with_borrow_clears_z_n() { - mpu.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + mpu.regP.D = false + mpu.regP.C = false // borrow = 1 + mpu.regA = 0x07 // $0000 SBC ($10) // $0010 Vector to $FEED writeMem(memory, 0x0000, listOf(0xF2, 0x10)) writeMem(memory, 0x0010, listOf(0xED, 0xFE)) memory[0xFEED] = 0x02 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) - assertEquals(0x04, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + assertEquals(0x04, mpu.regA) + assertFalse(mpu.regP.N) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.C) } // STZ Zero Page @@ -1310,7 +1310,7 @@ class Test65C02 : TestCommon6502() { assertEquals(0x88, memory[0x0032]) mpu.step() assertEquals(0x00, memory[0x0032]) - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(3 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1325,7 +1325,7 @@ class Test65C02 : TestCommon6502() { assertEquals(0x88, memory[0x0032]) mpu.step() assertEquals(0x00, memory[0x0032]) - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1339,7 +1339,7 @@ class Test65C02 : TestCommon6502() { assertEquals(0x88, memory[0xFEED]) mpu.step() assertEquals(0x00, memory[0xFEED]) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(4 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1348,14 +1348,14 @@ class Test65C02 : TestCommon6502() { @Test fun test_stz_abs_x_stores_zero() { memory[0xFEED] = 0x88 - mpu.X = 0x0D + mpu.regX = 0x0D // $0000 STZ $FEE0,X writeMem(memory, 0x0000, listOf(0x9E, 0xE0, 0xFE)) assertEquals(0x88, memory[0xFEED]) - assertEquals(0x0D, mpu.X) + assertEquals(0x0D, mpu.regX) mpu.step() assertEquals(0x00, memory[0xFEED]) - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1366,12 +1366,12 @@ class Test65C02 : TestCommon6502() { memory[0x00BB] = 0xE0 // $0000 TSB $BD writeMem(memory, 0x0000, listOf(0x04, 0xBB)) - mpu.A = 0x70 + mpu.regA = 0x70 assertEquals(0xE0, memory[0x00BB]) mpu.step() assertEquals(0xF0, memory[0x00BB]) - assertFalse(mpu.Status.Z) - assertEquals(0x0002, mpu.PC) + assertFalse(mpu.regP.Z) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1380,12 +1380,12 @@ class Test65C02 : TestCommon6502() { memory[0x00BB] = 0x80 // $0000 TSB $BD writeMem(memory, 0x0000, listOf(0x04, 0xBB)) - mpu.A = 0x60 + mpu.regA = 0x60 assertEquals(0x80, memory[0x00BB]) mpu.step() assertEquals(0xE0, memory[0x00BB]) - assertTrue(mpu.Status.Z) - assertEquals(0x0002, mpu.PC) + assertTrue(mpu.regP.Z) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1396,12 +1396,12 @@ class Test65C02 : TestCommon6502() { memory[0xFEED] = 0xE0 // $0000 TSB $FEED writeMem(memory, 0x0000, listOf(0x0C, 0xED, 0xFE)) - mpu.A = 0x70 + mpu.regA = 0x70 assertEquals(0xE0, memory[0xFEED]) mpu.step() assertEquals(0xF0, memory[0xFEED]) - assertFalse(mpu.Status.Z) - assertEquals(0x0003, mpu.PC) + assertFalse(mpu.regP.Z) + assertEquals(0x0003, mpu.regPC) assertEquals(6 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1410,12 +1410,12 @@ class Test65C02 : TestCommon6502() { memory[0xFEED] = 0x80 // $0000 TSB $FEED writeMem(memory, 0x0000, listOf(0x0C, 0xED, 0xFE)) - mpu.A = 0x60 + mpu.regA = 0x60 assertEquals(0x80, memory[0xFEED]) mpu.step() assertEquals(0xE0, memory[0xFEED]) - assertTrue(mpu.Status.Z) - assertEquals(0x0003, mpu.PC) + assertTrue(mpu.regP.Z) + assertEquals(0x0003, mpu.regPC) assertEquals(6 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1426,12 +1426,12 @@ class Test65C02 : TestCommon6502() { memory[0x00BB] = 0xE0 // $0000 TRB $BD writeMem(memory, 0x0000, listOf(0x14, 0xBB)) - mpu.A = 0x70 + mpu.regA = 0x70 assertEquals(0xE0, memory[0x00BB]) mpu.step() assertEquals(0x80, memory[0x00BB]) - assertFalse(mpu.Status.Z) - assertEquals(0x0002, mpu.PC) + assertFalse(mpu.regP.Z) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1440,12 +1440,12 @@ class Test65C02 : TestCommon6502() { memory[0x00BB] = 0x80 // $0000 TRB $BD writeMem(memory, 0x0000, listOf(0x14, 0xBB)) - mpu.A = 0x60 + mpu.regA = 0x60 assertEquals(0x80, memory[0x00BB]) mpu.step() assertEquals(0x80, memory[0x00BB]) - assertTrue(mpu.Status.Z) - assertEquals(0x0002, mpu.PC) + assertTrue(mpu.regP.Z) + assertEquals(0x0002, mpu.regPC) assertEquals(5 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1456,12 +1456,12 @@ class Test65C02 : TestCommon6502() { memory[0xFEED] = 0xE0 // $0000 TRB $FEED writeMem(memory, 0x0000, listOf(0x1C, 0xED, 0xFE)) - mpu.A = 0x70 + mpu.regA = 0x70 assertEquals(0xE0, memory[0xFEED]) mpu.step() assertEquals(0x80, memory[0xFEED]) - assertFalse(mpu.Status.Z) - assertEquals(0x0003, mpu.PC) + assertFalse(mpu.regP.Z) + assertEquals(0x0003, mpu.regPC) assertEquals(6 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1470,12 +1470,12 @@ class Test65C02 : TestCommon6502() { memory[0xFEED] = 0x80 // $0000 TRB $FEED writeMem(memory, 0x0000, listOf(0x1C, 0xED, 0xFE)) - mpu.A = 0x60 + mpu.regA = 0x60 assertEquals(0x80, memory[0xFEED]) mpu.step() assertEquals(0x80, memory[0xFEED]) - assertTrue(mpu.Status.Z) - assertEquals(0x0003, mpu.PC) + assertTrue(mpu.regP.Z) + assertEquals(0x0003, mpu.regPC) assertEquals(6 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1483,33 +1483,33 @@ class Test65C02 : TestCommon6502() { fun test_dec_a_decreases_a() { // $0000 DEC A memory[0x0000] = 0x3a - mpu.A = 0x48 + mpu.regA = 0x48 mpu.step() - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) - assertEquals(0x47, mpu.A) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.N) + assertEquals(0x47, mpu.regA) } @Test fun test_dec_a_sets_zero_flag() { // $0000 DEC A memory[0x0000] = 0x3a - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) - assertEquals(0x00, mpu.A) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) + assertEquals(0x00, mpu.regA) } @Test fun test_dec_a_wraps_at_zero() { // $0000 DEC A memory[0x0000] = 0x3a - mpu.A = 0x00 + mpu.regA = 0x00 mpu.step() - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) - assertEquals(0xFF, mpu.A) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) + assertEquals(0xFF, mpu.regA) } @Test @@ -1517,7 +1517,7 @@ class Test65C02 : TestCommon6502() { // $0000 BRA $10 writeMem(memory, 0x0000, listOf(0x80, 0x10)) mpu.step() - assertEquals(0x12, mpu.PC) + assertEquals(0x12, mpu.regPC) assertEquals(3 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1525,9 +1525,9 @@ class Test65C02 : TestCommon6502() { fun test_bra_backward() { // $0240 BRA $F0 writeMem(memory, 0x0204, listOf(0x80, 0xF0)) - mpu.PC = 0x0204 + mpu.regPC = 0x0204 mpu.step() - assertEquals(0x1F6, mpu.PC) + assertEquals(0x1F6, mpu.regPC) assertEquals(3 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) // Crossed boundry } @@ -1539,10 +1539,10 @@ class Test65C02 : TestCommon6502() { assertEquals(Cpu65C02.Wait.Normal, mpu.waiting) // $0240 WAI memory[0x0204] = 0xcb - mpu.PC = 0x0204 + mpu.regPC = 0x0204 mpu.step() assertEquals(Cpu65C02.Wait.Waiting, mpu.waiting) - assertEquals(0x0205, mpu.PC) + assertEquals(0x0205, mpu.regPC) assertEquals(3 + Cpu65C02.resetCycles, mpu.totalCycles.toInt()) } @@ -1550,7 +1550,7 @@ class Test65C02 : TestCommon6502() { @Test fun test_bbr_all_set_doesnt_branch() { mpu as Cpu65C02 - mpu.PC = 0 + mpu.regPC = 0 memory[0xfe] = 0xff writeMem(memory, 0, listOf(0x0f, 0xfe, 0x40, 0x1f, 0xfe, 0x40, @@ -1562,24 +1562,24 @@ class Test65C02 : TestCommon6502() { 0x7f, 0xfe, 0x40, 0xea)) repeat(8) { mpu.step() } - assertNotEquals(0x0040, mpu.PC) - assertEquals(0xea, memory[mpu.PC]) + assertNotEquals(0x0040, mpu.regPC) + assertEquals(0xea, memory[mpu.regPC]) } @Test fun test_bbr_branches() { mpu as Cpu65C02 - mpu.PC = 0 + mpu.regPC = 0 memory[0xfe] = 0b10111111 // bit 6 cleared writeMem(memory, 0, listOf(0x6f, 0xfe, 0x40)) // BBR6 $fe, $0040 mpu.step() - assertEquals(0x0043, mpu.PC) + assertEquals(0x0043, mpu.regPC) } @Test fun test_bbs_all_clear_doesnt_branch() { mpu as Cpu65C02 - mpu.PC = 0 + mpu.regPC = 0 memory[0xfe] = 0 writeMem(memory, 0, listOf(0x8f, 0xfe, 0x40, 0x9f, 0xfe, 0x40, @@ -1591,55 +1591,55 @@ class Test65C02 : TestCommon6502() { 0xff, 0xfe, 0x40, 0xea)) repeat(8) { mpu.step() } - assertNotEquals(0x0040, mpu.PC) - assertEquals(0xea, memory[mpu.PC]) + assertNotEquals(0x0040, mpu.regPC) + assertEquals(0xea, memory[mpu.regPC]) } @Test fun test_bbs_branches() { mpu as Cpu65C02 - mpu.PC = 0 + mpu.regPC = 0 memory[0xfe] = 0b01000000 // bit 6 set writeMem(memory, 0, listOf(0xef, 0xfe, 0x40)) // BBS6 $fe, $0040 mpu.step() - assertEquals(0x0043, mpu.PC) + assertEquals(0x0043, mpu.regPC) } @Test fun test_sbc_bcd_on_immediate_20_minus_0a_carry_unset() { - mpu.Status.D = true - mpu.Status.C = false - mpu.A = 0x20 + mpu.regP.D = true + mpu.regP.C = false + mpu.regA = 0x20 // $0000 SBC #$0a writeMem(memory, 0x0000, listOf(0xe9, 0x0a)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x0f, mpu.A) // 0x1f on 6502, 0x0f on 65c02 - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.V) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x0f, mpu.regA) // 0x1f on 6502, 0x0f on 65c02 + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.C) + assertFalse(mpu.regP.N) + assertFalse(mpu.regP.V) } @Test fun test_adc_bcd_on_immediate_9c_plus_9d() { - mpu.Status.D = true - mpu.Status.C = false - mpu.Status.N = true - mpu.A = 0x9c + mpu.regP.D = true + mpu.regP.C = false + mpu.regP.N = true + mpu.regA = 0x9c // $0000 ADC #$9d // $0002 ADC #$9d writeMem(memory, 0x0000, listOf(0x69, 0x9d)) writeMem(memory, 0x0002, listOf(0x69, 0x9d)) mpu.step() - assertEquals(0x9f, mpu.A) - assertTrue(mpu.Status.C) + assertEquals(0x9f, mpu.regA) + assertTrue(mpu.regP.C) mpu.step() - assertEquals(0x0004, mpu.PC) - assertEquals(0x93, mpu.A) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.V) - assertTrue(mpu.Status.N) // False on 6502, True on 65C02 + assertEquals(0x0004, mpu.regPC) + assertEquals(0x93, mpu.regA) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.C) + assertTrue(mpu.regP.V) + assertTrue(mpu.regP.N) // False on 6502, True on 65C02 } } diff --git a/src/test/kotlin/TestCommon6502.kt b/src/test/kotlin/TestCommon6502.kt index b182761..4011dca 100644 --- a/src/test/kotlin/TestCommon6502.kt +++ b/src/test/kotlin/TestCommon6502.kt @@ -1,4 +1,5 @@ import org.junit.jupiter.api.TestInstance +import razorvine.ksim65.* import razorvine.ksim65.components.* import kotlin.test.* @@ -55,7 +56,7 @@ abstract class TestCommon6502 { memory[Cpu6502.RESET_vector] = 0 memory[Cpu6502.RESET_vector + 1] = 0 mpu.reset() - mpu.Status.I = false // allow interrupts again + mpu.regP.I = false // allow interrupts again } companion object { @@ -82,1417 +83,1417 @@ abstract class TestCommon6502 { fun test_reset_sets_registers_to_initial_states() { mpu.reset() - assertEquals(0xFD, mpu.SP) - assertEquals(0, mpu.A) - assertEquals(0, mpu.X) - assertEquals(0, mpu.Y) - assertTrue(mpu.Status.I) // the other status flags are undefined after 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.A = 0 + 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.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + 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.A = 0 - mpu.Status.C = true + 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.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x01 + mpu.regA = 0x01 // $0000 ADC $C000 writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0)) memory[0xC000] = 0xFE mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + 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.A = 0x02 + mpu.regA = 0x02 // $0000 ADC $C000 writeMem(memory, 0x0000, listOf(0x6D, 0x00, 0xC0)) memory[0xC000] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.C = false - mpu.A = 0x01 + 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.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x01 + 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.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x7f + 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.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x80 + 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.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.V = false - mpu.A = 0x40 + 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.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + 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.A = 0 + mpu.regA = 0 // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + 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.A = 0 - mpu.Status.C = true + mpu.regA = 0 + mpu.regP.C = true // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x01 + mpu.regA = 0x01 // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0xFE mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + 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.A = 0x02 + mpu.regA = 0x02 // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0xff mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x7f + mpu.regP.C = false + mpu.regA = 0x7f // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x80 + mpu.regP.C = false + mpu.regA = 0x80 // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0xff mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + 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.A = 0x40 - mpu.Status.V = false + mpu.regA = 0x40 + mpu.regP.V = false // $0000 ADC $00B0 writeMem(memory, 0x0000, listOf(0x65, 0xB0)) memory[0x00B0] = 0x40 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + 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.A = 0 + mpu.regA = 0 // $0000 ADC #$00 writeMem(memory, 0x0000, listOf(0x69, 0x00)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + 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.A = 0 - mpu.Status.C = true + mpu.regA = 0 + mpu.regP.C = true // $0000 ADC #$00 writeMem(memory, 0x0000, listOf(0x69, 0x00)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x01 + mpu.regA = 0x01 // $0000 ADC #$FE writeMem(memory, 0x0000, listOf(0x69, 0xFE)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + 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.A = 0x02 + mpu.regA = 0x02 // $0000 ADC #$FF writeMem(memory, 0x0000, listOf(0x69, 0xFF)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC #$01 writeMem(memory, 0x000, listOf(0x69, 0x01)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC #$FF writeMem(memory, 0x000, listOf(0x69, 0xff)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x7f + mpu.regP.C = false + mpu.regA = 0x7f // $0000 ADC #$01 writeMem(memory, 0x000, listOf(0x69, 0x01)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x80 + mpu.regP.C = false + mpu.regA = 0x80 // $0000 ADC #$FF writeMem(memory, 0x000, listOf(0x69, 0xff)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + 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.A = 0x40 + mpu.regA = 0x40 // $0000 ADC #$40 writeMem(memory, 0x0000, listOf(0x69, 0x40)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + 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.Status.D = true - mpu.Status.C = true - mpu.A = 0x79 + 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.PC) - assertEquals(0x80, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) + 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.Status.D = true - mpu.Status.C = true - mpu.A = 0x6f + 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.PC) - assertEquals(0x76, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.V) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x00 - mpu.X = 0x03 + mpu.regA = 0x00 + mpu.regX = 0x03 // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0x00 + memory[0xC000 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + 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.A = 0 - mpu.X = 0x03 - mpu.Status.C = true + mpu.regA = 0 + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0x00 + memory[0xC000 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x01 - mpu.X = 0x03 + mpu.regA = 0x01 + mpu.regX = 0x03 // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0xFE + memory[0xC000 + mpu.regX] = 0xFE mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + 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.A = 0x02 - mpu.X = 0x03 + mpu.regA = 0x02 + mpu.regX = 0x03 // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0xFF + memory[0xC000 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0x01 + memory[0xC000 + mpu.regX] = 0x01 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0xff + memory[0xC000 + mpu.regX] = 0xff mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x7f + mpu.regP.C = false + mpu.regA = 0x7f // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0x01 + memory[0xC000 + mpu.regX] = 0x01 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x80 + mpu.regP.C = false + mpu.regA = 0x80 // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0xff + memory[0xC000 + mpu.regX] = 0xff mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.V = false - mpu.A = 0x40 - mpu.X = 0x03 + mpu.regP.V = false + mpu.regA = 0x40 + mpu.regX = 0x03 // $0000 ADC $C000,X writeMem(memory, 0x0000, listOf(0x7D, 0x00, 0xC0)) - memory[0xC000 + mpu.X] = 0x40 + memory[0xC000 + mpu.regX] = 0x40 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + 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.A = 0x00 - mpu.Y = 0x03 + mpu.regA = 0x00 + mpu.regY = 0x03 // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0x00 + memory[0xC000 + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + 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.A = 0 - mpu.Y = 0x03 - mpu.Status.C = true + mpu.regA = 0 + mpu.regY = 0x03 + mpu.regP.C = true // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0x00 + memory[0xC000 + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x01 - mpu.Y = 0x03 + mpu.regA = 0x01 + mpu.regY = 0x03 // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0xFE + memory[0xC000 + mpu.regY] = 0xFE mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + 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.A = 0x02 - mpu.Y = 0x03 + mpu.regA = 0x02 + mpu.regY = 0x03 // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0xFF + memory[0xC000 + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0x01 + memory[0xC000 + mpu.regY] = 0x01 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x01 + mpu.regP.C = false + mpu.regA = 0x01 // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0xFF + memory[0xC000 + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x7f + mpu.regP.C = false + mpu.regA = 0x7f // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0x01 + memory[0xC000 + mpu.regY] = 0x01 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x80 + mpu.regP.C = false + mpu.regA = 0x80 // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0xFF + memory[0xC000 + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.V = false - mpu.A = 0x40 - mpu.Y = 0x03 + mpu.regP.V = false + mpu.regA = 0x40 + mpu.regY = 0x03 // $0000 ADC $C000,Y writeMem(memory, 0x0000, listOf(0x79, 0x00, 0xC0)) - memory[0xC000 + mpu.Y] = 0x40 + memory[0xC000 + mpu.regY] = 0x40 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + 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.A = 0x00 - mpu.X = 0x03 + mpu.regA = 0x00 + mpu.regX = 0x03 // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + 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.A = 0 - mpu.X = 0x03 - mpu.Status.C = true + mpu.regA = 0 + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x01 - mpu.X = 0x03 + mpu.regA = 0x01 + mpu.regX = 0x03 // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0xFE + memory[0x0010 + mpu.regX] = 0xFE mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + 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.A = 0x02 - mpu.X = 0x03 + mpu.regA = 0x02 + mpu.regX = 0x03 // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.C = false - mpu.A = 0x01 - mpu.X = 0x03 + mpu.regP.C = false + mpu.regA = 0x01 + mpu.regX = 0x03 // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0x01 + memory[0x0010 + mpu.regX] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x01 - mpu.X = 0x03 + mpu.regP.C = false + mpu.regA = 0x01 + mpu.regX = 0x03 // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x7f - mpu.X = 0x03 + mpu.regP.C = false + mpu.regA = 0x7f + mpu.regX = 0x03 // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0x01 + memory[0x0010 + mpu.regX] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x80 - mpu.X = 0x03 + mpu.regP.C = false + mpu.regA = 0x80 + mpu.regX = 0x03 // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0xff + memory[0x0010 + mpu.regX] = 0xff mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.V = false - mpu.A = 0x40 - mpu.X = 0x03 + mpu.regP.V = false + mpu.regA = 0x40 + mpu.regX = 0x03 // $0000 ADC $0010,X writeMem(memory, 0x0000, listOf(0x75, 0x10)) - memory[0x0010 + mpu.X] = 0x40 + memory[0x0010 + mpu.regX] = 0x40 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + 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.A = 0x00 - mpu.X = 0x03 + 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.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + 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.A = 0 - mpu.X = 0x03 - mpu.Status.C = true + 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.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x01 - mpu.X = 0x03 + 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.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + 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.A = 0x02 - mpu.X = 0x03 + 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.PC) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.C = false - mpu.A = 0x01 - mpu.X = 0x03 + 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.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x01 - mpu.X = 0x03 + 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.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x7f - mpu.X = 0x03 + 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.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x80 - mpu.X = 0x03 + 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.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.V = false - mpu.A = 0x40 - mpu.X = 0x03 + 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.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + 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.A = 0x00 - mpu.Y = 0x03 + 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.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) + 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.A = 0 - mpu.Y = 0x03 - mpu.Status.C = true + 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.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + 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.A = 0x01 - mpu.Y = 0x03 + 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.Y] = 0xFE + memory[0xABCD + mpu.regY] = 0xFE mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.Z) + 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.A = 0x02 - mpu.Y = 0x03 + 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.Y] = 0xFF + memory[0xABCD + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, mpu.A) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.C = false - mpu.A = 0x01 - mpu.Y = 0x03 + 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.Y] = 0x01 + memory[0xABCD + mpu.regY] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x01 - mpu.Y = 0x03 + 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.Y] = 0xFF + memory[0xABCD + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x7f - mpu.Y = 0x03 + 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.Y] = 0x01 + memory[0xABCD + mpu.regY] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.C = false - mpu.A = 0x80 - mpu.Y = 0x03 + 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.Y] = 0xFF + memory[0xABCD + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x7f, mpu.A) - assertTrue(mpu.Status.V) + 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.Status.V = false - mpu.A = 0x40 - mpu.Y = 0x03 + 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.Y] = 0x40 + memory[0xABCD + mpu.regY] = 0x40 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertTrue(mpu.Status.V) - assertFalse(mpu.Status.Z) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 AND $ABCD writeMem(memory, 0x0000, listOf(0x2D, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 AND $ABCD writeMem(memory, 0x0000, listOf(0x2D, 0xCD, 0xAB)) memory[0xABCD] = 0xAA mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 AND $0010 writeMem(memory, 0x0000, listOf(0x25, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 AND $0010 writeMem(memory, 0x0000, listOf(0x25, 0x10)) memory[0x0010] = 0xAA mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 AND #$00 writeMem(memory, 0x0000, listOf(0x29, 0x00)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 AND #$AA writeMem(memory, 0x0000, listOf(0x29, 0xAA)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.X = 0x03 + mpu.regA = 0xFF + mpu.regX = 0x03 // $0000 AND $ABCD,X writeMem(memory, 0x0000, listOf(0x3d, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0xFF - mpu.X = 0x03 + mpu.regA = 0xFF + mpu.regX = 0x03 // $0000 AND $ABCD,X writeMem(memory, 0x0000, listOf(0x3d, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0xAA + memory[0xABCD + mpu.regX] = 0xAA mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.Y = 0x03 + mpu.regA = 0xFF + mpu.regY = 0x03 // $0000 AND $ABCD,X writeMem(memory, 0x0000, listOf(0x39, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0xFF - mpu.Y = 0x03 + mpu.regA = 0xFF + mpu.regY = 0x03 // $0000 AND $ABCD,X writeMem(memory, 0x0000, listOf(0x39, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0xAA + memory[0xABCD + mpu.regY] = 0xAA mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.X = 0x03 + 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.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0xFF - mpu.X = 0x03 + 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.PC) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.Y = 0x03 + 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.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0xFF - mpu.Y = 0x03 + 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.Y] = 0xAA + memory[0xABCD + mpu.regY] = 0xAA mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.X = 0x03 + mpu.regA = 0xFF + mpu.regX = 0x03 // $0000 AND $0010,X writeMem(memory, 0x0000, listOf(0x35, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0xFF - mpu.X = 0x03 + mpu.regA = 0xFF + mpu.regX = 0x03 // $0000 AND $0010,X writeMem(memory, 0x0000, listOf(0x35, 0x10)) - memory[0x0010 + mpu.X] = 0xAA + memory[0x0010 + mpu.regX] = 0xAA mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xAA, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0x00 + mpu.regA = 0x00 // $0000 ASL A memory[0x0000] = 0x0A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x40 + mpu.regA = 0x40 // $0000 ASL A memory[0x0000] = 0x0A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0x7F + mpu.regA = 0x7F // $0000 ASL A memory[0x0000] = 0x0A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xFE, mpu.A) - assertFalse(mpu.Status.C) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xFE, mpu.regA) + assertFalse(mpu.regP.C) } @Test fun test_asl_accumulator_shifts_out_one() { - mpu.A = 0xFF + mpu.regA = 0xFF // $0000 ASL A memory[0x0000] = 0x0A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xFE, mpu.A) - assertTrue(mpu.Status.C) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xFE, mpu.regA) + assertTrue(mpu.regP.C) } @Test fun test_asl_accumulator_80_sets_z_flag() { - mpu.A = 0x80 - mpu.Status.Z = false + mpu.regA = 0x80 + mpu.regP.Z = false // $0000 ASL A memory[0x0000] = 0x0A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) } // ASL Absolute @@ -1503,10 +1504,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0x0E, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test @@ -1515,36 +1516,36 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0x0E, 0xCD, 0xAB)) memory[0xABCD] = 0x40 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x80, memory[0xABCD]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } @Test fun test_asl_absolute_shifts_out_zero() { - mpu.A = 0xAA + mpu.regA = 0xAA // $0000 ASL $ABCD writeMem(memory, 0x0000, listOf(0x0E, 0xCD, 0xAB)) memory[0xABCD] = 0x7F mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xAA, mpu.A) + assertEquals(0x0003, mpu.regPC) + assertEquals(0xAA, mpu.regA) assertEquals(0xFE, memory[0xABCD]) - assertFalse(mpu.Status.C) + assertFalse(mpu.regP.C) } @Test fun test_asl_absolute_shifts_out_one() { - mpu.A = 0xAA + mpu.regA = 0xAA // $0000 ASL $ABCD writeMem(memory, 0x0000, listOf(0x0E, 0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xAA, mpu.A) + assertEquals(0x0003, mpu.regPC) + assertEquals(0xAA, mpu.regA) assertEquals(0xFE, memory[0xABCD]) - assertTrue(mpu.Status.C) + assertTrue(mpu.regP.C) } // ASL Zero Page @@ -1555,10 +1556,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0x06, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test @@ -1567,325 +1568,325 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0x06, 0x10)) memory[0x0010] = 0x40 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x80, memory[0x0010]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } @Test fun test_asl_zp_shifts_out_zero() { - mpu.A = 0xAA + mpu.regA = 0xAA // $0000 ASL $0010 writeMem(memory, 0x0000, listOf(0x06, 0x10)) memory[0x0010] = 0x7F mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xAA, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xAA, mpu.regA) assertEquals(0xFE, memory[0x0010]) - assertFalse(mpu.Status.C) + assertFalse(mpu.regP.C) } @Test fun test_asl_zp_shifts_out_one() { - mpu.A = 0xAA + mpu.regA = 0xAA // $0000 ASL $0010 writeMem(memory, 0x0000, listOf(0x06, 0x10)) memory[0x0010] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xAA, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xAA, mpu.regA) assertEquals(0xFE, memory[0x0010]) - assertTrue(mpu.Status.C) + assertTrue(mpu.regP.C) } // ASL Absolute, X-Indexed @Test fun test_asl_abs_x_indexed_sets_z_flag() { - mpu.X = 0x03 + mpu.regX = 0x03 // $0000 ASL $ABCD,X writeMem(memory, 0x0000, listOf(0x1E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 + mpu.regX = 0x03 // $0000 ASL $ABCD,X writeMem(memory, 0x0000, listOf(0x1E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x40 + memory[0xABCD + mpu.regX] = 0x40 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xAA - mpu.X = 0x03 + mpu.regA = 0xAA + mpu.regX = 0x03 // $0000 ASL $ABCD,X writeMem(memory, 0x0000, listOf(0x1E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x7F + memory[0xABCD + mpu.regX] = 0x7F mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xAA, mpu.A) - assertEquals(0xFE, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.C) + 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.A = 0xAA - mpu.X = 0x03 + mpu.regA = 0xAA + mpu.regX = 0x03 // $0000 ASL $ABCD,X writeMem(memory, 0x0000, listOf(0x1E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0xFF + memory[0xABCD + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xAA, mpu.A) - assertEquals(0xFE, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.C) + 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.X = 0x03 + mpu.regX = 0x03 // $0000 ASL $0010,X writeMem(memory, 0x0000, listOf(0x16, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 + mpu.regX = 0x03 // $0000 ASL $0010,X writeMem(memory, 0x0000, listOf(0x16, 0x10)) - memory[0x0010 + mpu.X] = 0x40 + memory[0x0010 + mpu.regX] = 0x40 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0x03 - mpu.A = 0xAA + mpu.regX = 0x03 + mpu.regA = 0xAA // $0000 ASL $0010,X writeMem(memory, 0x0000, listOf(0x16, 0x10)) - memory[0x0010 + mpu.X] = 0x7F + memory[0x0010 + mpu.regX] = 0x7F mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xAA, mpu.A) - assertEquals(0xFE, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.C) + 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.X = 0x03 - mpu.A = 0xAA + mpu.regX = 0x03 + mpu.regA = 0xAA // $0000 ASL $0010,X writeMem(memory, 0x0000, listOf(0x16, 0x10)) - memory[0x0010 + mpu.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xAA, mpu.A) - assertEquals(0xFE, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.C) + 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.Status.C = false + mpu.regP.C = false // $0000 BCC +6 writeMem(memory, 0x0000, listOf(0x90, 0x06)) mpu.step() - assertEquals(0x0002 + 0x06, mpu.PC) + assertEquals(0x0002 + 0x06, mpu.regPC) } @Test fun test_bcc_carry_clear_branches_relative_backward() { - mpu.Status.C = false - mpu.PC = 0x0050 + 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.PC) + assertEquals(0x0052 - 6, mpu.regPC) } @Test fun test_bcc_carry_set_does_not_branch() { - mpu.Status.C = true + mpu.regP.C = true // $0000 BCC +6 writeMem(memory, 0x0000, listOf(0x90, 0x06)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) } // BCS @Test fun test_bcs_carry_set_branches_relative_forward() { - mpu.Status.C = true + mpu.regP.C = true // $0000 BCS +6 writeMem(memory, 0x0000, listOf(0xB0, 0x06)) mpu.step() - assertEquals(0x0002 + 0x06, mpu.PC) + assertEquals(0x0002 + 0x06, mpu.regPC) } @Test fun test_bcs_carry_set_branches_relative_backward() { - mpu.Status.C = true - mpu.PC = 0x0050 + 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.PC) + assertEquals(0x0052 - 6, mpu.regPC) } @Test fun test_bcs_carry_clear_does_not_branch() { - mpu.Status.C = false + mpu.regP.C = false // $0000 BCS +6 writeMem(memory, 0x0000, listOf(0xB0, 0x06)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) } // BEQ @Test fun test_beq_zero_set_branches_relative_forward() { - mpu.Status.Z = true + mpu.regP.Z = true // $0000 BEQ +6 writeMem(memory, 0x0000, listOf(0xF0, 0x06)) mpu.step() - assertEquals(0x0002 + 0x06, mpu.PC) + assertEquals(0x0002 + 0x06, mpu.regPC) } @Test fun test_beq_zero_set_branches_relative_backward() { - mpu.Status.Z = true - mpu.PC = 0x0050 + 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.PC) + assertEquals(0x0052 - 6, mpu.regPC) } @Test fun test_beq_zero_clear_does_not_branch() { - mpu.Status.Z = false + mpu.regP.Z = false // $0000 BEQ +6 writeMem(memory, 0x0000, listOf(0xF0, 0x06)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) } // BIT (Absolute) @Test fun test_bit_abs_copies_bit_7_of_memory_to_n_flag_when_0() { - mpu.Status.N = false + mpu.regP.N = false // $0000 BIT $FEED writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE)) memory[0xFEED] = 0xFF - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertTrue(mpu.Status.N) + assertTrue(mpu.regP.N) } @Test fun test_bit_abs_copies_bit_7_of_memory_to_n_flag_when_1() { - mpu.Status.N = true + mpu.regP.N = true // $0000 BIT $FEED writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE)) memory[0xFEED] = 0x00 - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertFalse(mpu.Status.N) + assertFalse(mpu.regP.N) } @Test fun test_bit_abs_copies_bit_6_of_memory_to_v_flag_when_0() { - mpu.Status.V = false + mpu.regP.V = false // $0000 BIT $FEED writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE)) memory[0xFEED] = 0xFF - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertTrue(mpu.Status.V) + assertTrue(mpu.regP.V) } @Test fun test_bit_abs_copies_bit_6_of_memory_to_v_flag_when_1() { - mpu.Status.V = true + mpu.regP.V = true // $0000 BIT $FEED writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE)) memory[0xFEED] = 0x00 - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertFalse(mpu.Status.V) + assertFalse(mpu.regP.V) } @Test fun test_bit_abs_stores_result_of_and_in_z_preserves_a_when_1() { - mpu.Status.Z = false + mpu.regP.Z = false // $0000 BIT $FEED writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE)) memory[0xFEED] = 0x00 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertTrue(mpu.Status.Z) - assertEquals(0x01, mpu.A) + 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.Status.Z = true + mpu.regP.Z = true // $0000 BIT $FEED writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE)) memory[0xFEED] = 0x01 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertFalse(mpu.Status.Z) // result of AND is non-zero - assertEquals(0x01, mpu.A) + 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.Status.Z = false + mpu.regP.Z = false // $0000 BIT $FEED writeMem(memory, 0x0000, listOf(0x2C, 0xED, 0xFE)) memory[0xFEED] = 0x00 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertTrue(mpu.Status.Z) // result of AND is zero - assertEquals(0x01, mpu.A) + assertTrue(mpu.regP.Z) // result of AND is zero + assertEquals(0x01, mpu.regA) assertEquals(0x00, memory[0xFEED]) } @@ -1893,98 +1894,98 @@ abstract class TestCommon6502 { @Test fun test_bit_zp_copies_bit_7_of_memory_to_n_flag_when_0() { - mpu.Status.N = false + mpu.regP.N = false // $0000 BIT $0010 writeMem(memory, 0x0000, listOf(0x24, 0x10)) memory[0x0010] = 0xFF - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(3 + Cpu6502.resetCycles, mpu.totalCycles.toInt()) - assertTrue(mpu.Status.N) + assertTrue(mpu.regP.N) } @Test fun test_bit_zp_copies_bit_7_of_memory_to_n_flag_when_1() { - mpu.Status.N = true + mpu.regP.N = true // $0000 BIT $0010 writeMem(memory, 0x0000, listOf(0x24, 0x10)) memory[0x0010] = 0x00 - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(3 + Cpu6502.resetCycles, mpu.totalCycles.toInt()) - assertFalse(mpu.Status.N) + assertFalse(mpu.regP.N) } @Test fun test_bit_zp_copies_bit_6_of_memory_to_v_flag_when_0() { - mpu.Status.V = false + mpu.regP.V = false // $0000 BIT $0010 writeMem(memory, 0x0000, listOf(0x24, 0x10)) memory[0x0010] = 0xFF - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(3 + Cpu6502.resetCycles, mpu.totalCycles.toInt()) - assertTrue(mpu.Status.V) + assertTrue(mpu.regP.V) } @Test fun test_bit_zp_copies_bit_6_of_memory_to_v_flag_when_1() { - mpu.Status.V = true + mpu.regP.V = true // $0000 BIT $0010 writeMem(memory, 0x0000, listOf(0x24, 0x10)) memory[0x0010] = 0x00 - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(3 + Cpu6502.resetCycles, mpu.totalCycles.toInt()) - assertFalse(mpu.Status.V) + assertFalse(mpu.regP.V) } @Test fun test_bit_zp_stores_result_of_and_in_z_preserves_a_when_1() { - mpu.Status.Z = false + mpu.regP.Z = false // $0000 BIT $0010 writeMem(memory, 0x0000, listOf(0x24, 0x10)) memory[0x0010] = 0x00 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(3 + Cpu6502.resetCycles, mpu.totalCycles.toInt()) - assertTrue(mpu.Status.Z) - assertEquals(0x01, mpu.A) + 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.Status.Z = true + mpu.regP.Z = true // $0000 BIT $0010 writeMem(memory, 0x0000, listOf(0x24, 0x10)) memory[0x0010] = 0x01 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(3 + Cpu6502.resetCycles, mpu.totalCycles.toInt()) - assertFalse(mpu.Status.Z) // result of AND is non-zero - assertEquals(0x01, mpu.A) + 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.Status.Z = false + mpu.regP.Z = false // $0000 BIT $0010 writeMem(memory, 0x0000, listOf(0x24, 0x10)) memory[0x0010] = 0x00 - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(3 + Cpu6502.resetCycles, mpu.totalCycles.toInt()) - assertTrue(mpu.Status.Z) // result of AND is zero - assertEquals(0x01, mpu.A) + assertTrue(mpu.regP.Z) // result of AND is zero + assertEquals(0x01, mpu.regA) assertEquals(0x00, memory[0x0010]) } @@ -1992,93 +1993,93 @@ abstract class TestCommon6502 { @Test fun test_bmi_negative_set_branches_relative_forward() { - mpu.Status.N = true + mpu.regP.N = true // $0000 BMI +06 writeMem(memory, 0x0000, listOf(0x30, 0x06)) mpu.step() - assertEquals(0x0002 + 0x06, mpu.PC) + assertEquals(0x0002 + 0x06, mpu.regPC) } @Test fun test_bmi_negative_set_branches_relative_backward() { - mpu.Status.N = true - mpu.PC = 0x0050 + 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.PC) + assertEquals(0x0052 - 6, mpu.regPC) } @Test fun test_bmi_negative_clear_does_not_branch() { - mpu.Status.N = false + mpu.regP.N = false // $0000 BEQ +6 writeMem(memory, 0x0000, listOf(0x30, 0x06)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) } // BNE @Test fun test_bne_zero_clear_branches_relative_forward() { - mpu.Status.Z = false + mpu.regP.Z = false // $0000 BNE +6 writeMem(memory, 0x0000, listOf(0xD0, 0x06)) mpu.step() - assertEquals(0x0002 + 0x06, mpu.PC) + assertEquals(0x0002 + 0x06, mpu.regPC) } @Test fun test_bne_zero_clear_branches_relative_backward() { - mpu.Status.Z = false - mpu.PC = 0x0050 + 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.PC) + assertEquals(0x0052 - 6, mpu.regPC) } @Test fun test_bne_zero_set_does_not_branch() { - mpu.Status.Z = true + mpu.regP.Z = true // $0000 BNE +6 writeMem(memory, 0x0000, listOf(0xD0, 0x06)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) } // BPL @Test fun test_bpl_negative_clear_branches_relative_forward() { - mpu.Status.N = false + mpu.regP.N = false // $0000 BPL +06 writeMem(memory, 0x0000, listOf(0x10, 0x06)) mpu.step() - assertEquals(0x0002 + 0x06, mpu.PC) + assertEquals(0x0002 + 0x06, mpu.regPC) } @Test fun test_bpl_negative_clear_branches_relative_backward() { - mpu.Status.N = false - mpu.PC = 0x0050 + 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.PC) + assertEquals(0x0052 - 6, mpu.regPC) } @Test fun test_bpl_negative_set_does_not_branch() { - mpu.Status.N = true + mpu.regP.N = true // $0000 BPL +6 writeMem(memory, 0x0000, listOf(0x10, 0x06)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) } // BRK @@ -2086,127 +2087,127 @@ abstract class TestCommon6502 { @Test fun test_brk_pushes_pc_plus_2_and_status_then_sets_pc_to_irq_vector() { writeMem(memory, 0xFFFE, listOf(0xCD, 0xAB)) - mpu.SP = 0xff - mpu.Status.I = false + mpu.regSP = 0xff + mpu.regP.I = false // $C000 BRK memory[0xC000] = 0x00 - mpu.PC = 0xC000 + mpu.regPC = 0xC000 mpu.step() - assertEquals(0xABCD, mpu.PC) + assertEquals(0xABCD, mpu.regPC) - assertEquals(0xFC, mpu.SP) + 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.Status.asByte().toInt()) + assertEquals(fBREAK or fUNUSED or fINTERRUPT, mpu.regP.asByte().toInt()) } // BVC @Test fun test_bvc_overflow_clear_branches_relative_forward() { - mpu.Status.V = false + mpu.regP.V = false // $0000 BVC +6 writeMem(memory, 0x0000, listOf(0x50, 0x06)) mpu.step() - assertEquals(0x0002 + 0x06, mpu.PC) + assertEquals(0x0002 + 0x06, mpu.regPC) } @Test fun test_bvc_overflow_clear_branches_relative_backward() { - mpu.Status.V = false - mpu.PC = 0x0050 + 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.PC) + assertEquals(0x0052 - 6, mpu.regPC) } @Test fun test_bvc_overflow_set_does_not_branch() { - mpu.Status.V = true + mpu.regP.V = true // $0000 BVC +6 writeMem(memory, 0x0000, listOf(0x50, 0x06)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) } // BVS @Test fun test_bvs_overflow_set_branches_relative_forward() { - mpu.Status.V = true + mpu.regP.V = true // $0000 BVS +6 writeMem(memory, 0x0000, listOf(0x70, 0x06)) mpu.step() - assertEquals(0x0002 + 0x06, mpu.PC) + assertEquals(0x0002 + 0x06, mpu.regPC) } @Test fun test_bvs_overflow_set_branches_relative_backward() { - mpu.Status.V = true - mpu.PC = 0x0050 + 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.PC) + assertEquals(0x0052 - 6, mpu.regPC) } @Test fun test_bvs_overflow_clear_does_not_branch() { - mpu.Status.V = false + mpu.regP.V = false // $0000 BVS +6 writeMem(memory, 0x0000, listOf(0x70, 0x06)) mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) } // CLC @Test fun test_clc_clears_carry_flag() { - mpu.Status.C = true + mpu.regP.C = true // $0000 CLC memory[0x0000] = 0x18 mpu.step() - assertEquals(0x0001, mpu.PC) - assertFalse(mpu.Status.C) + assertEquals(0x0001, mpu.regPC) + assertFalse(mpu.regP.C) } // CLD @Test fun test_cld_clears_decimal_flag() { - mpu.Status.D = true + mpu.regP.D = true // $0000 CLD memory[0x0000] = 0xD8 mpu.step() - assertEquals(0x0001, mpu.PC) - assertFalse(mpu.Status.D) + assertEquals(0x0001, mpu.regPC) + assertFalse(mpu.regP.D) } // CLI @Test fun test_cli_clears_interrupt_mask_flag() { - mpu.Status.I = true + mpu.regP.I = true // $0000 CLI memory[0x0000] = 0x58 mpu.step() - assertEquals(0x0001, mpu.PC) - assertFalse(mpu.Status.I) + assertEquals(0x0001, mpu.regPC) + assertFalse(mpu.regP.I) } // CLV @Test fun test_clv_clears_overflow_flag() { - mpu.Status.V = true + mpu.regP.V = true // $0000 CLV memory[0x0000] = 0xB8 mpu.step() - assertEquals(0x0001, mpu.PC) - assertFalse(mpu.Status.V) + assertEquals(0x0001, mpu.regPC) + assertFalse(mpu.regP.V) } // Compare instructions @@ -2227,12 +2228,12 @@ abstract class TestCommon6502 { // Comparison: A == m // $0000 CMP #10 , A will be 10 writeMem(memory, 0x0000, listOf(0xC9, 10)) - mpu.A = 10 + mpu.regA = 10 mpu.step() - assertEquals(0x0002, mpu.PC) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.Z) - assertTrue(mpu.Status.C) + assertEquals(0x0002, mpu.regPC) + assertFalse(mpu.regP.N) + assertTrue(mpu.regP.Z) + assertTrue(mpu.regP.C) } @Test @@ -2240,12 +2241,12 @@ abstract class TestCommon6502 { // Comparison: A < m (unsigned) // $0000 CMP #10 , A will be 1 writeMem(memory, 0x0000, listOf(0xC9, 10)) - mpu.A = 1 + mpu.regA = 1 mpu.step() - assertEquals(0x0002, mpu.PC) - assertTrue(mpu.Status.N) // 0x01-0x0A=0xF7 - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) + assertEquals(0x0002, mpu.regPC) + assertTrue(mpu.regP.N) // 0x01-0x0A=0xF7 + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.C) } @Test @@ -2253,12 +2254,12 @@ abstract class TestCommon6502 { // Comparison: A < #nn (signed), A negative // $0000 CMP #1, A will be -1 (0xFF) writeMem(memory, 0x0000, listOf(0xC9, 1)) - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertTrue(mpu.Status.N) // 0xFF-0x01=0xFE - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) // A>m unsigned + assertEquals(0x0002, mpu.regPC) + assertTrue(mpu.regP.N) // 0xFF-0x01=0xFE + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.C) // A>m unsigned } @Test @@ -2266,12 +2267,12 @@ abstract class TestCommon6502 { // 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.A = 0xFE + mpu.regA = 0xFE mpu.step() - assertEquals(0x0002, mpu.PC) - assertTrue(mpu.Status.N) // 0xFE-0xFF=0xFF - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) // A m (unsigned) // $0000 CMP #1 , A will be 10 writeMem(memory, 0x0000, listOf(0xC9, 1)) - mpu.A = 10 + mpu.regA = 10 mpu.step() - assertEquals(0x0002, mpu.PC) - assertFalse(mpu.Status.N) // 0x0A-0x01 = 0x09 - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) // A>m unsigned + assertEquals(0x0002, mpu.regPC) + assertFalse(mpu.regP.N) // 0x0A-0x01 = 0x09 + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.C) // A>m unsigned } @Test @@ -2292,12 +2293,12 @@ abstract class TestCommon6502 { // Comparison: A > m (signed), memory negative // $0000 CMP #$FF (-1), A will be 2 writeMem(memory, 0x0000, listOf(0xC9, 0xFF)) - mpu.A = 2 + mpu.regA = 2 mpu.step() - assertEquals(0x0002, mpu.PC) - assertFalse(mpu.Status.N) // 0x02-0xFF=0x01 - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) // A m (signed), A and m both negative // $0000 CMP #$FE (-2), A will be -1 (0xFF) writeMem(memory, 0x0000, listOf(0xC9, 0xFE)) - mpu.A = 0xFF + mpu.regA = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertFalse(mpu.Status.N) // 0xFF-0xFE=0x01 - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) // A>m unsigned + assertEquals(0x0002, mpu.regPC) + assertFalse(mpu.regP.N) // 0xFF-0xFE=0x01 + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.C) // A>m unsigned } // CPX Immediate @@ -2320,12 +2321,12 @@ abstract class TestCommon6502 { // Comparison: X == m // $0000 CPX #$20 writeMem(memory, 0x0000, listOf(0xE0, 0x20)) - mpu.X = 0x20 + mpu.regX = 0x20 mpu.step() - assertEquals(0x0002, mpu.PC) - assertTrue(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) + assertEquals(0x0002, mpu.regPC) + assertTrue(mpu.regP.Z) + assertTrue(mpu.regP.C) + assertFalse(mpu.regP.N) } // CPY Immediate @@ -2335,12 +2336,12 @@ abstract class TestCommon6502 { // Comparison: Y == m // $0000 CPY #$30 writeMem(memory, 0x0000, listOf(0xC0, 0x30)) - mpu.Y = 0x30 + mpu.regY = 0x30 mpu.step() - assertEquals(0x0002, mpu.PC) - assertTrue(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) + assertEquals(0x0002, mpu.regPC) + assertTrue(mpu.regP.Z) + assertTrue(mpu.regP.C) + assertFalse(mpu.regP.N) } // DEC Absolute @@ -2350,10 +2351,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xCE, 0xCD, 0xAB)) memory[0xABCD] = 0x10 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x0F, memory[0xABCD]) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertFalse(mpu.regP.N) + assertFalse(mpu.regP.Z) } @Test @@ -2362,10 +2363,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xCE, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0xFF, memory[0xABCD]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) } @Test @@ -2374,10 +2375,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xCE, 0xCD, 0xAB)) memory[0xABCD] = 0x01 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } // DEC Zero Page @@ -2388,10 +2389,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xC6, 0x10)) memory[0x0010] = 0x10 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x0F, memory[0x0010]) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertFalse(mpu.regP.N) + assertFalse(mpu.regP.Z) } @Test @@ -2400,10 +2401,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xC6, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0xFF, memory[0x0010]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) } @Test @@ -2412,10 +2413,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xC6, 0x10)) memory[0x0010] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } // DEC Absolute, X-Indexed @@ -2424,37 +2425,37 @@ abstract class TestCommon6502 { fun test_dec_abs_x_decrements_memory() { // $0000 DEC 0xABCD,X writeMem(memory, 0x0000, listOf(0xDE, 0xCD, 0xAB)) - mpu.X = 0x03 - memory[0xABCD + mpu.X] = 0x10 + mpu.regX = 0x03 + memory[0xABCD + mpu.regX] = 0x10 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x0F, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + 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.X] = 0x01 + memory[0xABCD + mpu.regX] = 0x01 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertEquals(0x0003, mpu.regPC) + assertEquals(0x00, memory[0xABCD + mpu.regX]) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } // DEC Zero Page, X-Indexed @@ -2463,339 +2464,339 @@ abstract class TestCommon6502 { fun test_dec_zp_x_decrements_memory() { // $0000 DEC 0x0010,X writeMem(memory, 0x0000, listOf(0xD6, 0x10)) - mpu.X = 0x03 - memory[0x0010 + mpu.X] = 0x10 + mpu.regX = 0x03 + memory[0x0010 + mpu.regX] = 0x10 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x0F, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0x03 - memory[0x0010 + mpu.X] = 0x00 + mpu.regX = 0x03 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + 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.X = 0x03 - memory[0x0010 + mpu.X] = 0x01 + mpu.regX = 0x03 + memory[0x0010 + mpu.regX] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x10 + mpu.regX = 0x10 // $0000 DEX memory[0x0000] = 0xCA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x0F, mpu.X) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0x00 + mpu.regX = 0x00 // $0000 DEX memory[0x0000] = 0xCA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xFF, mpu.X) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0x01 + mpu.regX = 0x01 // $0000 DEX memory[0x0000] = 0xCA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x00, mpu.regX) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } // DEY @Test fun test_dey_decrements_y() { - mpu.Y = 0x10 + mpu.regY = 0x10 // $0000 DEY memory[0x0000] = 0x88 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x0F, mpu.Y) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Y = 0x00 + mpu.regY = 0x00 // $0000 DEY memory[0x0000] = 0x88 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xFF, mpu.Y) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xFF, mpu.regY) + assertTrue(mpu.regP.N) } @Test fun test_dey_sets_zero_flag_when_decrementing_to_zero() { - mpu.Y = 0x01 + mpu.regY = 0x01 // $0000 DEY memory[0x0000] = 0x88 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) + 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.A = 0xFF + mpu.regA = 0xFF writeMem(memory, 0x0000, listOf(0x4D, 0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) + assertEquals(0x0003, mpu.regPC) + assertEquals(0x00, mpu.regA) assertEquals(0xFF, memory[0xABCD]) - assertTrue(mpu.Status.Z) + assertTrue(mpu.regP.Z) } @Test fun test_eor_absolute_flips_bits_over_setting_n_flag() { - mpu.A = 0x00 + mpu.regA = 0x00 writeMem(memory, 0x0000, listOf(0x4D, 0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, mpu.A) + assertEquals(0x0003, mpu.regPC) + assertEquals(0xFF, mpu.regA) assertEquals(0xFF, memory[0xABCD]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } // EOR Zero Page @Test fun test_eor_zp_flips_bits_over_setting_z_flag() { - mpu.A = 0xFF + mpu.regA = 0xFF writeMem(memory, 0x0000, listOf(0x45, 0x10)) memory[0x0010] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, mpu.regA) assertEquals(0xFF, memory[0x0010]) - assertTrue(mpu.Status.Z) + assertTrue(mpu.regP.Z) } @Test fun test_eor_zp_flips_bits_over_setting_n_flag() { - mpu.A = 0x00 + mpu.regA = 0x00 writeMem(memory, 0x0000, listOf(0x45, 0x10)) memory[0x0010] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xFF, mpu.regA) assertEquals(0xFF, memory[0x0010]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } // EOR Immediate @Test fun test_eor_immediate_flips_bits_over_setting_z_flag() { - mpu.A = 0xFF + mpu.regA = 0xFF writeMem(memory, 0x0000, listOf(0x49, 0xFF)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) } @Test fun test_eor_immediate_flips_bits_over_setting_n_flag() { - mpu.A = 0x00 + mpu.regA = 0x00 writeMem(memory, 0x0000, listOf(0x49, 0xFF)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.X = 0x03 + mpu.regA = 0xFF + mpu.regX = 0x03 writeMem(memory, 0x0000, listOf(0x5D, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0xFF + memory[0xABCD + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertEquals(0xFF, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) + 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.A = 0x00 - mpu.X = 0x03 + mpu.regA = 0x00 + mpu.regX = 0x03 writeMem(memory, 0x0000, listOf(0x5D, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0xFF + memory[0xABCD + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, mpu.A) - assertEquals(0xFF, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.Y = 0x03 + mpu.regA = 0xFF + mpu.regY = 0x03 writeMem(memory, 0x0000, listOf(0x59, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0xFF + memory[0xABCD + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertEquals(0xFF, memory[0xABCD + mpu.Y]) - assertTrue(mpu.Status.Z) + 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.A = 0x00 - mpu.Y = 0x03 + mpu.regA = 0x00 + mpu.regY = 0x03 writeMem(memory, 0x0000, listOf(0x59, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0xFF + memory[0xABCD + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, mpu.A) - assertEquals(0xFF, memory[0xABCD + mpu.Y]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.X = 0x03 + 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.PC) - assertEquals(0x00, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, mpu.regA) assertEquals(0xFF, memory[0xABCD]) - assertTrue(mpu.Status.Z) + assertTrue(mpu.regP.Z) } @Test fun test_eor_ind_indexed_x_flips_bits_over_setting_n_flag() { - mpu.A = 0x00 - mpu.X = 0x03 + 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.PC) - assertEquals(0xFF, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xFF, mpu.regA) assertEquals(0xFF, memory[0xABCD]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.Y = 0x03 + 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.Y] = 0xFF + memory[0xABCD + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertEquals(0xFF, memory[0xABCD + mpu.Y]) - assertTrue(mpu.Status.Z) + 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.A = 0x00 - mpu.Y = 0x03 + 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.Y] = 0xFF + memory[0xABCD + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, mpu.A) - assertEquals(0xFF, memory[0xABCD + mpu.Y]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.X = 0x03 + mpu.regA = 0xFF + mpu.regX = 0x03 writeMem(memory, 0x0000, listOf(0x55, 0x10)) - memory[0x0010 + mpu.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertEquals(0xFF, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) + 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.A = 0x00 - mpu.X = 0x03 + mpu.regA = 0x00 + mpu.regX = 0x03 writeMem(memory, 0x0000, listOf(0x55, 0x10)) - memory[0x0010 + mpu.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, mpu.A) - assertEquals(0xFF, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xFF, mpu.regA) + assertEquals(0xFF, memory[0x0010 + mpu.regX]) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } // INC Absolute @@ -2805,10 +2806,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xEE, 0xCD, 0xAB)) memory[0xABCD] = 0x09 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x0A, memory[0xABCD]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test @@ -2816,10 +2817,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xEE, 0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test @@ -2827,10 +2828,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xEE, 0xCD, 0xAB)) memory[0xABCD] = 0x7F mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x80, memory[0xABCD]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) } // INC Zero Page @@ -2840,10 +2841,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xE6, 0x10)) memory[0x0010] = 0x09 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x0A, memory[0x0010]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test @@ -2851,10 +2852,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xE6, 0x10)) memory[0x0010] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test @@ -2862,10 +2863,10 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0xE6, 0x10)) memory[0x0010] = 0x7F mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x80, memory[0x0010]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) } // INC Absolute, X-Indexed @@ -2873,37 +2874,37 @@ abstract class TestCommon6502 { @Test fun test_inc_abs_x_increments_memory() { writeMem(memory, 0x0000, listOf(0xFE, 0xCD, 0xAB)) - mpu.X = 0x03 - memory[0xABCD + mpu.X] = 0x09 + mpu.regX = 0x03 + memory[0xABCD + mpu.regX] = 0x09 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x0A, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 - memory[0xABCD + mpu.X] = 0xFF + mpu.regX = 0x03 + memory[0xABCD + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 - memory[0xABCD + mpu.X] = 0x7F + mpu.regX = 0x03 + memory[0xABCD + mpu.regX] = 0x7F mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + assertEquals(0x0003, mpu.regPC) + assertEquals(0x80, memory[0xABCD + mpu.regX]) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) } // INC Zero Page, X-Indexed @@ -2911,101 +2912,101 @@ abstract class TestCommon6502 { @Test fun test_inc_zp_x_increments_memory() { writeMem(memory, 0x0000, listOf(0xF6, 0x10)) - mpu.X = 0x03 - memory[0x0010 + mpu.X] = 0x09 + mpu.regX = 0x03 + memory[0x0010 + mpu.regX] = 0x09 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x0A, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X] = 0x7F + memory[0x0010 + mpu.regX] = 0x7F mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + 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.X = 0x09 + mpu.regX = 0x09 memory[0x0000] = 0xE8 // => INX mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x0A, mpu.X) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0xFF + mpu.regX = 0xFF memory[0x0000] = 0xE8 // => INX mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x00, mpu.regX) + assertTrue(mpu.regP.Z) } @Test fun test_inx_sets_negative_flag_when_incrementing_above_7F() { - mpu.X = 0x7f + mpu.regX = 0x7f memory[0x0000] = 0xE8 // => INX mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x80, mpu.regX) + assertTrue(mpu.regP.N) } // INY @Test fun test_iny_increments_y() { - mpu.Y = 0x09 + mpu.regY = 0x09 memory[0x0000] = 0xC8 // => INY mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x0A, mpu.Y) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Y = 0xFF + mpu.regY = 0xFF memory[0x0000] = 0xC8 // => INY mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x00, mpu.regY) + assertTrue(mpu.regP.Z) } @Test fun test_iny_sets_negative_flag_when_incrementing_above_7F() { - mpu.Y = 0x7f + mpu.regY = 0x7f memory[0x0000] = 0xC8 // => INY mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.Y) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x80, mpu.regY) + assertTrue(mpu.regP.N) } // JMP Absolute @@ -3015,7 +3016,7 @@ abstract class TestCommon6502 { // $0000 JMP $ABCD writeMem(memory, 0x0000, listOf(0x4C, 0xCD, 0xAB)) mpu.step() - assertEquals(0xABCD, mpu.PC) + assertEquals(0xABCD, mpu.regPC) } // JMP Indirect @@ -3026,7 +3027,7 @@ abstract class TestCommon6502 { writeMem(memory, 0x0000, listOf(0x6C, 0x00, 0x02)) writeMem(memory, 0x0200, listOf(0xCD, 0xAB)) mpu.step() - assertEquals(0xABCD, mpu.PC) + assertEquals(0xABCD, mpu.regPC) } // JSR @@ -3034,12 +3035,12 @@ abstract class TestCommon6502 { @Test fun test_jsr_pushes_pc_plus_2_and_sets_pc() { // $C000 JSR $FFD2 - mpu.SP = 0xFF + mpu.regSP = 0xFF writeMem(memory, 0xC000, listOf(0x20, 0xD2, 0xFF)) - mpu.PC = 0xC000 + mpu.regPC = 0xC000 mpu.step() - assertEquals(0xFFD2, mpu.PC) - assertEquals(0xFD, mpu.SP) + assertEquals(0xFFD2, mpu.regPC) + assertEquals(0xFD, mpu.regSP) assertEquals(0xC0, memory[0x01FF]) // PCH assertEquals(0x02, memory[0x01FE]) // PCL+2 } @@ -3048,799 +3049,799 @@ abstract class TestCommon6502 { @Test fun test_lda_absolute_loads_a_sets_n_flag() { - mpu.A = 0x00 + mpu.regA = 0x00 // $0000 LDA $ABCD writeMem(memory, 0x0000, listOf(0xAD, 0xCD, 0xAB)) memory[0xABCD] = 0x80 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 LDA $ABCD writeMem(memory, 0x0000, listOf(0xAD, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x00 + mpu.regA = 0x00 // $0000 LDA $0010 writeMem(memory, 0x0000, listOf(0xA5, 0x10)) memory[0x0010] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 LDA $0010 writeMem(memory, 0x0000, listOf(0xA5, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x00 + mpu.regA = 0x00 // $0000 LDA #$80 writeMem(memory, 0x0000, listOf(0xA9, 0x80)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF + mpu.regA = 0xFF // $0000 LDA #$00 writeMem(memory, 0x0000, listOf(0xA9, 0x00)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x00 - mpu.X = 0x03 + mpu.regA = 0x00 + mpu.regX = 0x03 // $0000 LDA $ABCD,X writeMem(memory, 0x0000, listOf(0xBD, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x80 + memory[0xABCD + mpu.regX] = 0x80 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.X = 0x03 + mpu.regA = 0xFF + mpu.regX = 0x03 // $0000 LDA $ABCD,X writeMem(memory, 0x0000, listOf(0xBD, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0 - mpu.X = 0xFF + mpu.regA = 0 + mpu.regX = 0xFF // $0000 LDA $0080,X writeMem(memory, 0x0000, listOf(0xBD, 0x80, 0x00)) - memory[0x0080 + mpu.X] = 0x42 + memory[0x0080 + mpu.regX] = 0x42 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x42, mpu.A) + 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.A = 0x00 - mpu.Y = 0x03 + mpu.regA = 0x00 + mpu.regY = 0x03 // $0000 LDA $ABCD,Y writeMem(memory, 0x0000, listOf(0xB9, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0x80 + memory[0xABCD + mpu.regY] = 0x80 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xFF - mpu.Y = 0x03 + mpu.regA = 0xFF + mpu.regY = 0x03 // $0000 LDA $ABCD,Y writeMem(memory, 0x0000, listOf(0xB9, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0 - mpu.Y = 0xFF + mpu.regA = 0 + mpu.regY = 0xFF // $0000 LDA $0080,X writeMem(memory, 0x0000, listOf(0xB9, 0x80, 0x00)) - memory[0x0080 + mpu.Y] = 0x42 + memory[0x0080 + mpu.regY] = 0x42 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x42, mpu.A) + 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.A = 0x00 - mpu.X = 0x03 + 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.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0x00 - mpu.X = 0x03 + 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.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x00 - mpu.Y = 0x03 + 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.Y] = 0x80 + memory[0xABCD + mpu.regY] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0x00 - mpu.Y = 0xf3 + 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.Y] = 0x80 + memory[0xABCD + mpu.regY] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x80, mpu.regA) } @Test fun test_lda_indexed_ind_y_loads_a_sets_z_flag() { - mpu.A = 0x00 - mpu.Y = 0x03 + 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.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x00 - mpu.X = 0x03 + mpu.regA = 0x00 + mpu.regX = 0x03 // $0000 LDA $10,X writeMem(memory, 0x0000, listOf(0xB5, 0x10)) - memory[0x0010 + mpu.X] = 0x80 + memory[0x0010 + mpu.regX] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0x00 - mpu.X = 0xf3 + mpu.regA = 0x00 + mpu.regX = 0xf3 // $0000 LDA $10,X writeMem(memory, 0x0000, listOf(0xB5, 0x10)) - memory[(0x0010 + mpu.X) and 255] = 0x80 + memory[(0x0010 + mpu.regX) and 255] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.A) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x80, mpu.regA) } @Test fun test_lda_zp_x_indexed_loads_a_sets_z_flag() { - mpu.A = 0xFF - mpu.X = 0x03 + mpu.regA = 0xFF + mpu.regX = 0x03 // $0000 LDA $10,X writeMem(memory, 0x0000, listOf(0xB5, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x00 + mpu.regX = 0x00 // $0000 LDX $ABCD writeMem(memory, 0x0000, listOf(0xAE, 0xCD, 0xAB)) memory[0xABCD] = 0x80 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0xFF + mpu.regX = 0xFF // $0000 LDX $ABCD writeMem(memory, 0x0000, listOf(0xAE, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x00 + mpu.regX = 0x00 // $0000 LDX $0010 writeMem(memory, 0x0000, listOf(0xA6, 0x10)) memory[0x0010] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0xFF + mpu.regX = 0xFF // $0000 LDX $0010 writeMem(memory, 0x0000, listOf(0xA6, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x00 + mpu.regX = 0x00 // $0000 LDX #$80 writeMem(memory, 0x0000, listOf(0xA2, 0x80)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0xFF + mpu.regX = 0xFF // $0000 LDX #$00 writeMem(memory, 0x0000, listOf(0xA2, 0x00)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x00 - mpu.Y = 0x03 + mpu.regX = 0x00 + mpu.regY = 0x03 // $0000 LDX $ABCD,Y writeMem(memory, 0x0000, listOf(0xBE, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0x80 + memory[0xABCD + mpu.regY] = 0x80 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0xFF - mpu.Y = 0x03 + mpu.regX = 0xFF + mpu.regY = 0x03 // $0000 LDX $ABCD,Y writeMem(memory, 0x0000, listOf(0xBE, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x00 - mpu.Y = 0x03 + mpu.regX = 0x00 + mpu.regY = 0x03 // $0000 LDX $0010,Y writeMem(memory, 0x0000, listOf(0xB6, 0x10)) - memory[0x0010 + mpu.Y] = 0x80 + memory[0x0010 + mpu.regY] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0xFF - mpu.Y = 0x03 + mpu.regX = 0xFF + mpu.regY = 0x03 // $0000 LDX $0010,Y writeMem(memory, 0x0000, listOf(0xB6, 0x10)) - memory[0x0010 + mpu.Y] = 0x00 + memory[0x0010 + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Y = 0x00 + mpu.regY = 0x00 // $0000 LDY $ABCD writeMem(memory, 0x0000, listOf(0xAC, 0xCD, 0xAB)) memory[0xABCD] = 0x80 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.Y) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Y = 0xFF + mpu.regY = 0xFF // $0000 LDY $ABCD writeMem(memory, 0x0000, listOf(0xAC, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Y = 0x00 + mpu.regY = 0x00 // $0000 LDY $0010 writeMem(memory, 0x0000, listOf(0xA4, 0x10)) memory[0x0010] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.Y) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Y = 0xFF + mpu.regY = 0xFF // $0000 LDY $0010 writeMem(memory, 0x0000, listOf(0xA4, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Y = 0x00 + mpu.regY = 0x00 // $0000 LDY #$80 writeMem(memory, 0x0000, listOf(0xA0, 0x80)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.Y) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Y = 0xFF + mpu.regY = 0xFF // $0000 LDY #$00 writeMem(memory, 0x0000, listOf(0xA0, 0x00)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Y = 0x00 - mpu.X = 0x03 + mpu.regY = 0x00 + mpu.regX = 0x03 // $0000 LDY $ABCD,X writeMem(memory, 0x0000, listOf(0xBC, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x80 + memory[0xABCD + mpu.regX] = 0x80 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, mpu.Y) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Y = 0xFF - mpu.X = 0x03 + mpu.regY = 0xFF + mpu.regX = 0x03 // $0000 LDY $ABCD,X writeMem(memory, 0x0000, listOf(0xBC, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Y = 0x00 - mpu.X = 0x03 + mpu.regY = 0x00 + mpu.regX = 0x03 // $0000 LDY $0010,X writeMem(memory, 0x0000, listOf(0xB4, 0x10)) - memory[0x0010 + mpu.X] = 0x80 + memory[0x0010 + mpu.regX] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, mpu.Y) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Y = 0xFF - mpu.X = 0x03 + mpu.regY = 0xFF + mpu.regX = 0x03 // $0000 LDY $0010,X writeMem(memory, 0x0000, listOf(0xB4, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Status.C = true + mpu.regP.C = true // $0000 LSR A memory[0x0000] = (0x4A) - mpu.A = 0x00 + mpu.regA = 0x00 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = false + mpu.regP.C = false // $0000 LSR A memory[0x0000] = (0x4A) - mpu.A = 0x01 + mpu.regA = 0x01 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = true + mpu.regP.C = true // $0000 LSR A memory[0x0000] = (0x4A) - mpu.A = 0x04 + mpu.regA = 0x04 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x02, mpu.A) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = true + mpu.regP.C = true // $0000 LSR $ABCD writeMem(memory, 0x0000, listOf(0x4E, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = false + mpu.regP.C = false // $0000 LSR $ABCD writeMem(memory, 0x0000, listOf(0x4E, 0xCD, 0xAB)) memory[0xABCD] = 0x01 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertTrue(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertTrue(mpu.regP.C) + assertFalse(mpu.regP.N) } @Test fun test_lsr_absolute_rotates_bits_right() { - mpu.Status.C = true + mpu.regP.C = true // $0000 LSR $ABCD writeMem(memory, 0x0000, listOf(0x4E, 0xCD, 0xAB)) memory[0xABCD] = 0x04 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x02, memory[0xABCD]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = true + mpu.regP.C = true // $0000 LSR $0010 writeMem(memory, 0x0000, listOf(0x46, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = false + mpu.regP.C = false // $0000 LSR $0010 writeMem(memory, 0x0000, listOf(0x46, 0x10)) memory[0x0010] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertTrue(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertTrue(mpu.regP.C) + assertFalse(mpu.regP.N) } @Test fun test_lsr_zp_rotates_bits_right() { - mpu.Status.C = true + mpu.regP.C = true // $0000 LSR $0010 writeMem(memory, 0x0000, listOf(0x46, 0x10)) memory[0x0010] = 0x04 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x02, memory[0x0010]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = true - mpu.X = 0x03 + mpu.regP.C = true + mpu.regX = 0x03 // $0000 LSR $ABCD,X writeMem(memory, 0x0000, listOf(0x5E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = false - mpu.X = 0x03 + mpu.regP.C = false + mpu.regX = 0x03 // $0000 LSR $ABCD,X writeMem(memory, 0x0000, listOf(0x5E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x01 + memory[0xABCD + mpu.regX] = 0x01 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = true + mpu.regP.C = true // $0000 LSR $ABCD,X writeMem(memory, 0x0000, listOf(0x5E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x04 + memory[0xABCD + mpu.regX] = 0x04 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x02, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = true - mpu.X = 0x03 + mpu.regP.C = true + mpu.regX = 0x03 // $0000 LSR $0010,X writeMem(memory, 0x0000, listOf(0x56, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = false - mpu.X = 0x03 + mpu.regP.C = false + mpu.regX = 0x03 // $0000 LSR $0010,X writeMem(memory, 0x0000, listOf(0x56, 0x10)) - memory[0x0010 + mpu.X] = 0x01 + memory[0x0010 + mpu.regX] = 0x01 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertFalse(mpu.Status.N) + 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.Status.C = true - mpu.X = 0x03 + mpu.regP.C = true + mpu.regX = 0x03 // $0000 LSR $0010,X writeMem(memory, 0x0000, listOf(0x56, 0x10)) - memory[0x0010 + mpu.X] = 0x04 + memory[0x0010 + mpu.regX] = 0x04 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x02, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.C) - assertFalse(mpu.Status.N) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x02, memory[0x0010 + mpu.regX]) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.C) + assertFalse(mpu.regP.N) } // NOP @@ -3850,268 +3851,268 @@ abstract class TestCommon6502 { // $0000 NOP memory[0x0000] = 0xEA mpu.step() - assertEquals(0x0001, mpu.PC) + assertEquals(0x0001, mpu.regPC) } // ORA Absolute @Test fun test_ora_absolute_zeroes_or_zeros_sets_z_flag() { - mpu.Status.Z = false - mpu.A = 0x00 + 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.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + assertEquals(0x0003, mpu.regPC) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) } @Test fun test_ora_absolute_turns_bits_on_sets_n_flag() { - mpu.Status.N = false - mpu.A = 0x03 + 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.PC) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.Z = false - mpu.A = 0x00 + mpu.regP.Z = false + mpu.regA = 0x00 // $0000 ORA $0010 writeMem(memory, 0x0000, listOf(0x05, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) } @Test fun test_ora_zp_turns_bits_on_sets_n_flag() { - mpu.Status.N = false - mpu.A = 0x03 + mpu.regP.N = false + mpu.regA = 0x03 // $0000 ORA $0010 writeMem(memory, 0x0000, listOf(0x05, 0x10)) memory[0x0010] = 0x82 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.Z = false - mpu.A = 0x00 + mpu.regP.Z = false + mpu.regA = 0x00 // $0000 ORA #$00 writeMem(memory, 0x0000, listOf(0x09, 0x00)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, mpu.regA) + assertTrue(mpu.regP.Z) } @Test fun test_ora_immediate_turns_bits_on_sets_n_flag() { - mpu.Status.N = false - mpu.A = 0x03 + mpu.regP.N = false + mpu.regA = 0x03 // $0000 ORA #$82 writeMem(memory, 0x0000, listOf(0x09, 0x82)) mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.Z = false - mpu.A = 0x00 - mpu.X = 0x03 + mpu.regP.Z = false + mpu.regA = 0x00 + mpu.regX = 0x03 // $0000 ORA $ABCD,X writeMem(memory, 0x0000, listOf(0x1D, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + 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.Status.N = false - mpu.A = 0x03 - mpu.X = 0x03 + mpu.regP.N = false + mpu.regA = 0x03 + mpu.regX = 0x03 // $0000 ORA $ABCD,X writeMem(memory, 0x0000, listOf(0x1D, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x82 + memory[0xABCD + mpu.regX] = 0x82 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.Z = false - mpu.A = 0x00 - mpu.Y = 0x03 + mpu.regP.Z = false + mpu.regA = 0x00 + mpu.regY = 0x03 // $0000 ORA $ABCD,Y writeMem(memory, 0x0000, listOf(0x19, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + 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.Status.N = false - mpu.A = 0x03 - mpu.Y = 0x03 + mpu.regP.N = false + mpu.regA = 0x03 + mpu.regY = 0x03 // $0000 ORA $ABCD,Y writeMem(memory, 0x0000, listOf(0x19, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0x82 + memory[0xABCD + mpu.regY] = 0x82 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.Z = false - mpu.A = 0x00 - mpu.X = 0x03 + 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.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + 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.Status.N = false - mpu.A = 0x03 - mpu.X = 0x03 + 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.PC) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.Z = false - mpu.A = 0x00 - mpu.Y = 0x03 + 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.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + 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.Status.N = false - mpu.A = 0x03 - mpu.Y = 0x03 + 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.Y] = 0x82 + memory[0xABCD + mpu.regY] = 0x82 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.Status.Z = false - mpu.A = 0x00 - mpu.X = 0x03 + mpu.regP.Z = false + mpu.regA = 0x00 + mpu.regX = 0x03 // $0000 ORA $0010,X writeMem(memory, 0x0000, listOf(0x15, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) + 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.Status.N = false - mpu.A = 0x03 - mpu.X = 0x03 + mpu.regP.N = false + mpu.regA = 0x03 + mpu.regX = 0x03 // $0000 ORA $0010,X writeMem(memory, 0x0000, listOf(0x15, 0x10)) - memory[0x0010 + mpu.X] = 0x82 + memory[0x0010 + mpu.regX] = 0x82 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x83, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0xAB + mpu.regA = 0xAB // $0000 PHA memory[0x0000] = 0x48 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.A) - assertEquals(0xFC, mpu.SP) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regA) + assertEquals(0xFC, mpu.regSP) assertEquals(0xAB, memory[0x01FD]) } @@ -4121,12 +4122,12 @@ abstract class TestCommon6502 { fun test_php_pushes_processor_status_and_updates_sp() { for (flags in 0 until 0x100) { mpu.reset() - mpu.Status.fromByte(flags or fBREAK or fUNUSED) + mpu.regP.fromByte(flags or fBREAK or fUNUSED) // $0000 PHP memory[0x0000] = 0x08 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xFC, mpu.SP) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xFC, mpu.regSP) assertEquals((flags or fBREAK or fUNUSED), memory[0x1FD].toInt()) } } @@ -4138,11 +4139,11 @@ abstract class TestCommon6502 { // $0000 PLA memory[0x0000] = 0x68 memory[0x01FF] = 0xAB - mpu.SP = 0xFE + mpu.regSP = 0xFE mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.A) - assertEquals(0xFF, mpu.SP) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regA) + assertEquals(0xFF, mpu.regSP) } // PLP @@ -4152,688 +4153,688 @@ abstract class TestCommon6502 { // $0000 PLP memory[0x0000] = 0x28 memory[0x01FF] = 0xBA // must have BREAK and UNUSED set - mpu.SP = 0xFE + mpu.regSP = 0xFE mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xBA, mpu.Status.asByte()) - assertEquals(0xFF, mpu.SP) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xBA, mpu.regP.asByte()) + assertEquals(0xFF, mpu.regSP) } // ROL Accumulator @Test fun test_rol_accumulator_zero_and_carry_zero_sets_z_flag() { - mpu.A = 0x00 - mpu.Status.C = false + mpu.regA = 0x00 + mpu.regP.C = false // $0000 ROL A memory[0x0000] = 0x2A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x80 - mpu.Status.C = false - mpu.Status.Z = false + mpu.regA = 0x80 + mpu.regP.C = false + mpu.regP.Z = false // $0000 ROL A memory[0x0000] = 0x2A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x00 - mpu.Status.C = true + mpu.regA = 0x00 + mpu.regP.C = true // $0000 ROL A memory[0x0000] = 0x2A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x01, mpu.A) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x40 - mpu.Status.C = true + mpu.regA = 0x40 + mpu.regP.C = true // $0000 ROL A memory[0x0000] = 0x2A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x81, mpu.A) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.A = 0x7F - mpu.Status.C = false + mpu.regA = 0x7F + mpu.regP.C = false // $0000 ROL A memory[0x0000] = 0x2A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xFE, mpu.A) - assertFalse(mpu.Status.C) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xFE, mpu.regA) + assertFalse(mpu.regP.C) } @Test fun test_rol_accumulator_shifts_out_one() { - mpu.A = 0xFF - mpu.Status.C = false + mpu.regA = 0xFF + mpu.regP.C = false // $0000 ROL A memory[0x0000] = 0x2A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xFE, mpu.A) - assertTrue(mpu.Status.C) + 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.Status.C = false + mpu.regP.C = false // $0000 ROL $ABCD writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_rol_absolute_80_and_carry_zero_sets_z_flag() { - mpu.Status.C = false - mpu.Status.Z = false + 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.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_rol_absolute_zero_and_carry_one_clears_z_flag() { - mpu.A = 0x00 - mpu.Status.C = true + 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.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x01, memory[0xABCD]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_rol_absolute_sets_n_flag() { - mpu.Status.C = true + mpu.regP.C = true // $0000 ROL $ABCD writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB)) memory[0xABCD] = 0x40 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x81, memory[0xABCD]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } @Test fun test_rol_absolute_shifts_out_zero() { - mpu.Status.C = false + mpu.regP.C = false // $0000 ROL $ABCD writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB)) memory[0xABCD] = 0x7F mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0xFE, memory[0xABCD]) - assertFalse(mpu.Status.C) + assertFalse(mpu.regP.C) } @Test fun test_rol_absolute_shifts_out_one() { - mpu.Status.C = false + mpu.regP.C = false // $0000 ROL $ABCD writeMem(memory, 0x0000, listOf(0x2E, 0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0xFE, memory[0xABCD]) - assertTrue(mpu.Status.C) + assertTrue(mpu.regP.C) } // ROL Zero Page @Test fun test_rol_zp_zero_and_carry_zero_sets_z_flag() { - mpu.Status.C = false + mpu.regP.C = false // $0000 ROL $0010 writeMem(memory, 0x0000, listOf(0x26, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_rol_zp_80_and_carry_zero_sets_z_flag() { - mpu.Status.C = false - mpu.Status.Z = false + 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.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_rol_zp_zero_and_carry_one_clears_z_flag() { - mpu.A = 0x00 - mpu.Status.C = true + mpu.regA = 0x00 + mpu.regP.C = true // $0000 ROL $0010 writeMem(memory, 0x0000, listOf(0x26, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x01, memory[0x0010]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_rol_zp_sets_n_flag() { - mpu.Status.C = true + mpu.regP.C = true // $0000 ROL $0010 writeMem(memory, 0x0000, listOf(0x26, 0x10)) memory[0x0010] = 0x40 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x81, memory[0x0010]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + assertTrue(mpu.regP.N) + assertFalse(mpu.regP.Z) } @Test fun test_rol_zp_shifts_out_zero() { - mpu.Status.C = false + mpu.regP.C = false // $0000 ROL $0010 writeMem(memory, 0x0000, listOf(0x26, 0x10)) memory[0x0010] = 0x7F mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0xFE, memory[0x0010]) - assertFalse(mpu.Status.C) + assertFalse(mpu.regP.C) } @Test fun test_rol_zp_shifts_out_one() { - mpu.Status.C = false + mpu.regP.C = false // $0000 ROL $0010 writeMem(memory, 0x0000, listOf(0x26, 0x10)) memory[0x0010] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0xFE, memory[0x0010]) - assertTrue(mpu.Status.C) + assertTrue(mpu.regP.C) } // ROL Absolute, X-Indexed @Test fun test_rol_abs_x_indexed_zero_and_carry_zero_sets_z_flag() { - mpu.Status.C = false - mpu.X = 0x03 + mpu.regP.C = false + mpu.regX = 0x03 // $0000 ROL $ABCD,X writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Status.C = false - mpu.Status.Z = false - mpu.X = 0x03 + 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.X] = 0x80 + memory[0xABCD + mpu.regX] = 0x80 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROL $ABCD,X writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x01, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROL $ABCD,X writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x40 + memory[0xABCD + mpu.regX] = 0x40 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x81, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0x03 - mpu.Status.C = false + mpu.regX = 0x03 + mpu.regP.C = false // $0000 ROL $ABCD,X writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x7F + memory[0xABCD + mpu.regX] = 0x7F mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFE, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.C) + 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.X = 0x03 - mpu.Status.C = false + mpu.regX = 0x03 + mpu.regP.C = false // $0000 ROL $ABCD,X writeMem(memory, 0x0000, listOf(0x3E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0xFF + memory[0xABCD + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFE, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.C) + 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.Status.C = false - mpu.X = 0x03 + mpu.regP.C = false + mpu.regX = 0x03 writeMem(memory, 0x0000, listOf(0x36, 0x10)) // $0000 ROL $0010,X - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.Status.C = false - mpu.Status.Z = false - mpu.X = 0x03 + mpu.regP.C = false + mpu.regP.Z = false + mpu.regX = 0x03 writeMem(memory, 0x0000, listOf(0x36, 0x10)) // $0000 ROL $0010,X - memory[0x0010 + mpu.X] = 0x80 + memory[0x0010 + mpu.regX] = 0x80 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true writeMem(memory, 0x0000, listOf(0x36, 0x10)) // $0000 ROL $0010,X - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x01, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROL $0010,X writeMem(memory, 0x0000, listOf(0x36, 0x10)) - memory[0x0010 + mpu.X] = 0x40 + memory[0x0010 + mpu.regX] = 0x40 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x81, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.Z) + 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.X = 0x03 - mpu.Status.C = false + mpu.regX = 0x03 + mpu.regP.C = false // $0000 ROL $0010,X writeMem(memory, 0x0000, listOf(0x36, 0x10)) - memory[0x0010 + mpu.X] = 0x7F + memory[0x0010 + mpu.regX] = 0x7F mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFE, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.C) + 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.X = 0x03 - mpu.Status.C = false + mpu.regX = 0x03 + mpu.regP.C = false // $0000 ROL $0010,X writeMem(memory, 0x0000, listOf(0x36, 0x10)) - memory[0x0010 + mpu.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFE, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.C) + 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.A = 0x00 - mpu.Status.C = false + mpu.regA = 0x00 + mpu.regP.C = false // $0000 ROR A memory[0x0000] = 0x6A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.A = 0x00 - mpu.Status.C = true + mpu.regA = 0x00 + mpu.regP.C = true // $0000 ROR A memory[0x0000] = 0x6A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.A) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + 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.A = 0x02 - mpu.Status.C = true + mpu.regA = 0x02 + mpu.regP.C = true // $0000 ROR A memory[0x0000] = 0x6A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x81, mpu.A) - assertFalse(mpu.Status.C) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x81, mpu.regA) + assertFalse(mpu.regP.C) } @Test fun test_ror_accumulator_shifts_out_one() { - mpu.A = 0x03 - mpu.Status.C = true + mpu.regA = 0x03 + mpu.regP.C = true // $0000 ROR A memory[0x0000] = 0x6A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x81, mpu.A) - assertTrue(mpu.Status.C) + 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.Status.C = false + mpu.regP.C = false // $0000 ROR $ABCD writeMem(memory, 0x0000, listOf(0x6E, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_ror_absolute_zero_and_carry_one_rotates_in_sets_n_flags() { - mpu.Status.C = true + mpu.regP.C = true // $0000 ROR $ABCD writeMem(memory, 0x0000, listOf(0x6E, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x80, memory[0xABCD]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) } @Test fun test_ror_absolute_shifts_out_zero() { - mpu.Status.C = true + mpu.regP.C = true // $0000 ROR $ABCD writeMem(memory, 0x0000, listOf(0x6E, 0xCD, 0xAB)) memory[0xABCD] = 0x02 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x81, memory[0xABCD]) - assertFalse(mpu.Status.C) + assertFalse(mpu.regP.C) } @Test fun test_ror_absolute_shifts_out_one() { - mpu.Status.C = true + mpu.regP.C = true // $0000 ROR $ABCD writeMem(memory, 0x0000, listOf(0x6E, 0xCD, 0xAB)) memory[0xABCD] = 0x03 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x81, memory[0xABCD]) - assertTrue(mpu.Status.C) + assertTrue(mpu.regP.C) } // ROR Zero Page @Test fun test_ror_zp_zero_and_carry_zero_sets_z_flag() { - mpu.Status.C = false + mpu.regP.C = false // $0000 ROR $0010 writeMem(memory, 0x0000, listOf(0x66, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + assertTrue(mpu.regP.Z) + assertFalse(mpu.regP.N) } @Test fun test_ror_zp_zero_and_carry_one_rotates_in_sets_n_flags() { - mpu.Status.C = true + mpu.regP.C = true // $0000 ROR $0010 writeMem(memory, 0x0000, listOf(0x66, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x80, memory[0x0010]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + assertFalse(mpu.regP.Z) + assertTrue(mpu.regP.N) } @Test fun test_ror_zp_zero_absolute_shifts_out_zero() { - mpu.Status.C = true + mpu.regP.C = true // $0000 ROR $0010 writeMem(memory, 0x0000, listOf(0x66, 0x10)) memory[0x0010] = 0x02 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x81, memory[0x0010]) - assertFalse(mpu.Status.C) + assertFalse(mpu.regP.C) } @Test fun test_ror_zp_shifts_out_one() { - mpu.Status.C = true + mpu.regP.C = true // $0000 ROR $0010 writeMem(memory, 0x0000, listOf(0x66, 0x10)) memory[0x0010] = 0x03 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x81, memory[0x0010]) - assertTrue(mpu.Status.C) + assertTrue(mpu.regP.C) } // ROR Absolute, X-Indexed @Test fun test_ror_abs_x_indexed_zero_and_carry_zero_sets_z_flag() { - mpu.X = 0x03 - mpu.Status.C = false + mpu.regX = 0x03 + mpu.regP.C = false // $0000 ROR $ABCD,X writeMem(memory, 0x0000, listOf(0x7E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROR $ABCD,X writeMem(memory, 0x0000, listOf(0x7E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x80, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROR $ABCD,X writeMem(memory, 0x0000, listOf(0x7E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x02 + memory[0xABCD + mpu.regX] = 0x02 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x81, memory[0xABCD + mpu.X]) - assertFalse(mpu.Status.C) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROR $ABCD,X writeMem(memory, 0x0000, listOf(0x7E, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x03 + memory[0xABCD + mpu.regX] = 0x03 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x81, memory[0xABCD + mpu.X]) - assertTrue(mpu.Status.C) + 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.X = 0x03 - mpu.Status.C = false + mpu.regX = 0x03 + mpu.regP.C = false // $0000 ROR $0010,X writeMem(memory, 0x0000, listOf(0x76, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.Z) - assertFalse(mpu.Status.N) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROR $0010,X writeMem(memory, 0x0000, listOf(0x76, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x80, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROR $0010,X writeMem(memory, 0x0000, listOf(0x76, 0x10)) - memory[0x0010 + mpu.X] = 0x02 + memory[0x0010 + mpu.regX] = 0x02 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x81, memory[0x0010 + mpu.X]) - assertFalse(mpu.Status.C) + 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.X = 0x03 - mpu.Status.C = true + mpu.regX = 0x03 + mpu.regP.C = true // $0000 ROR $0010,X writeMem(memory, 0x0000, listOf(0x76, 0x10)) - memory[0x0010 + mpu.X] = 0x03 + memory[0x0010 + mpu.regX] = 0x03 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x81, memory[0x0010 + mpu.X]) - assertTrue(mpu.Status.C) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x81, memory[0x0010 + mpu.regX]) + assertTrue(mpu.regP.C) } // RTI @@ -4843,11 +4844,11 @@ abstract class TestCommon6502 { // $0000 RTI memory[0x0000] = 0x40 writeMem(memory, 0x01FD, listOf(0xFC, 0x03, 0xC0)) // Status, PCL, PCH - mpu.SP = 0xFC + mpu.regSP = 0xFC mpu.step() - assertEquals(0xFF, mpu.SP) - assertEquals(0xFC, mpu.Status.asByte()) - assertEquals(0xC003, mpu.PC) + assertEquals(0xFF, mpu.regSP) + assertEquals(0xFC, mpu.regP.asByte()) + assertEquals(0xC003, mpu.regPC) } @Test @@ -4855,9 +4856,9 @@ abstract class TestCommon6502 { // $0000 RTI memory[0x0000] = 0x40 writeMem(memory, 0x01FD, listOf(0x00, 0x03, 0xC0)) // Status, PCL, PCH - mpu.SP = 0xFC + mpu.regSP = 0xFC mpu.step() - assertTrue(mpu.Status.B) + assertTrue(mpu.regP.B) // assertEquals(fUNUSED, mpu.Status.asByte().toInt() and fUNUSED) } @@ -4868,11 +4869,11 @@ abstract class TestCommon6502 { // $0000 RTS memory[0x0000] = 0x60 writeMem(memory, 0x01FE, listOf(0x03, 0xC0)) // PCL, PCH - mpu.PC = 0x0000 - mpu.SP = 0xFD + mpu.regPC = 0x0000 + mpu.regSP = 0xFD mpu.step() - assertEquals(0xC004, mpu.PC) - assertEquals(0xFF, mpu.SP) + assertEquals(0xC004, mpu.regPC) + assertEquals(0xFF, mpu.regSP) } @Test @@ -4880,623 +4881,623 @@ abstract class TestCommon6502 { // $1000 RTS memory[0x1000] = 0x60 writeMem(memory, 0x01FE, listOf(0xFF, 0xFF)) // PCL, PCH - mpu.PC = 0x1000 - mpu.SP = 0xFD + mpu.regPC = 0x1000 + mpu.regSP = 0xFD mpu.step() - assertEquals(0x0000, mpu.PC) - assertEquals(0xFF, mpu.SP) + assertEquals(0x0000, mpu.regPC) + assertEquals(0xFF, mpu.regSP) } // SBC Absolute @Test fun test_sbc_abs_all_zeros_and_no_borrow_is_zero() { - mpu.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + 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.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + 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.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + 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.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + 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.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.D = true - mpu.Status.C = true - mpu.A = 0x0a + 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.PC) - assertEquals(0x0a, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.V) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.D = true - mpu.Status.C = true - mpu.A = 0x9a + 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.PC) - assertEquals(0x9a, mpu.A) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.V) + 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.Status.D = true - mpu.Status.V = true - mpu.Status.Z = true - mpu.Status.C = true - mpu.Status.N = false - mpu.A = 0x00 + 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.PC) - assertEquals(0x99, mpu.A) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.N) - assertFalse(mpu.Status.V) - assertFalse(mpu.Status.C) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 + 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.X = 0x0D + mpu.regX = 0x0D memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + 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.X = 0x0D + mpu.regX = 0x0D memory[0xFEED] = 0x01 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + 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.X = 0x0D + mpu.regX = 0x0D memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + 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.X = 0x0D + mpu.regX = 0x0D memory[0xFEED] = 0x02 mpu.step() - assertEquals(0x04, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 + 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.Y = 0x0D + mpu.regY = 0x0D memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + 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.Y = 0x0D + mpu.regY = 0x0D memory[0xFEED] = 0x01 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + 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.Y = 0x0D + mpu.regY = 0x0D memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + 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.Y = 0x0D + mpu.regY = 0x0D memory[0xFEED] = 0x02 mpu.step() - assertEquals(0x04, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 + 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.X = 0x03 + mpu.regX = 0x03 memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + 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.X = 0x03 + mpu.regX = 0x03 memory[0xFEED] = 0x01 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + 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.X = 0x03 + mpu.regX = 0x03 memory[0xFEED] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + 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.X = 0x03 + mpu.regX = 0x03 memory[0xFEED] = 0x02 mpu.step() - assertEquals(0x04, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 - mpu.Y = 0x03 + 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.Y] = 0x00 + memory[0xFEED + mpu.regY] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + 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.Y] = 0x01 + memory[0xFEED + mpu.regY] = 0x01 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + 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.Y] = 0x00 + memory[0xFEED + mpu.regY] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + 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.Y] = 0x02 + memory[0xFEED + mpu.regY] = 0x02 mpu.step() - assertEquals(0x04, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x00 + mpu.regP.D = false + mpu.regP.C = true // borrow = 0 + mpu.regA = 0x00 // $0000 SBC $10,X writeMem(memory, 0x0000, listOf(0xF5, 0x10)) - mpu.X = 0x0D + mpu.regX = 0x0D memory[0x001D] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = true // borrow = 0 - mpu.A = 0x01 + mpu.regP.D = false + mpu.regP.C = true // borrow = 0 + mpu.regA = 0x01 // $0000 SBC $10,X writeMem(memory, 0x0000, listOf(0xF5, 0x10)) - mpu.X = 0x0D + mpu.regX = 0x0D memory[0x001D] = 0x01 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x01 + mpu.regP.D = false + mpu.regP.C = false // borrow = 1 + mpu.regA = 0x01 // $0000 SBC $10,X writeMem(memory, 0x0000, listOf(0xF5, 0x10)) - mpu.X = 0x0D + mpu.regX = 0x0D memory[0x001D] = 0x00 mpu.step() - assertEquals(0x00, mpu.A) - assertFalse(mpu.Status.N) - assertTrue(mpu.Status.C) - assertTrue(mpu.Status.Z) + 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.Status.D = false - mpu.Status.C = false // borrow = 1 - mpu.A = 0x07 + mpu.regP.D = false + mpu.regP.C = false // borrow = 1 + mpu.regA = 0x07 // $0000 SBC $10,X writeMem(memory, 0x0000, listOf(0xF5, 0x10)) - mpu.X = 0x0D + mpu.regX = 0x0D memory[0x001D] = 0x02 mpu.step() - assertEquals(0x04, mpu.A) - assertFalse(mpu.Status.N) - assertFalse(mpu.Status.Z) - assertTrue(mpu.Status.C) + 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.Status.C = false + mpu.regP.C = false // $0000 SEC memory[0x0000] = 0x038 mpu.step() - assertEquals(0x0001, mpu.PC) - assertTrue(mpu.Status.C) + assertEquals(0x0001, mpu.regPC) + assertTrue(mpu.regP.C) } // SED @Test fun test_sed_sets_decimal_mode_flag() { - mpu.Status.D = false + mpu.regP.D = false // $0000 SED memory[0x0000] = 0xF8 mpu.step() - assertEquals(0x0001, mpu.PC) - assertTrue(mpu.Status.D) + assertEquals(0x0001, mpu.regPC) + assertTrue(mpu.regP.D) } // SEI @Test fun test_sei_sets_interrupt_disable_flag() { - mpu.Status.I = false + mpu.regP.I = false // $0000 SEI memory[0x0000] = 0x78 mpu.step() - assertEquals(0x0001, mpu.PC) - assertTrue(mpu.Status.I) + assertEquals(0x0001, mpu.regPC) + assertTrue(mpu.regP.I) } // STA Absolute @@ -5504,31 +5505,31 @@ abstract class TestCommon6502 { @Test fun test_sta_absolute_stores_a_leaves_a_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.A = 0xFF + mpu.regP.fromByte(flags) + mpu.regA = 0xFF // $0000 STA $ABCD writeMem(memory, 0x0000, listOf(0x8D, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0xFF, memory[0xABCD]) - assertEquals(0xFF, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0xFF, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sta_absolute_stores_a_leaves_a_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.A = 0x00 + mpu.regP.fromByte(flags) + mpu.regA = 0x00 // $0000 STA $ABCD writeMem(memory, 0x0000, listOf(0x8D, 0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertEquals(0x00, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x00, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STA Zero Page @@ -5536,31 +5537,31 @@ abstract class TestCommon6502 { @Test fun test_sta_zp_stores_a_leaves_a_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.A = 0xFF + mpu.regP.fromByte(flags) + mpu.regA = 0xFF // $0000 STA $0010 writeMem(memory, 0x0000, listOf(0x85, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0xFF, memory[0x0010]) - assertEquals(0xFF, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0xFF, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sta_zp_stores_a_leaves_a_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.A = 0x00 + mpu.regP.fromByte(flags) + mpu.regA = 0x00 // $0000 STA $0010 writeMem(memory, 0x0000, listOf(0x85, 0x10)) memory[0x0010] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertEquals(0x00, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x00, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STA Absolute, X-Indexed @@ -5568,33 +5569,33 @@ abstract class TestCommon6502 { @Test fun test_sta_abs_x_indexed_stores_a_leaves_a_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.A = 0xFF - mpu.X = 0x03 + mpu.regP.fromByte(flags) + mpu.regA = 0xFF + mpu.regX = 0x03 // $0000 STA $ABCD,X writeMem(memory, 0x0000, listOf(0x9D, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0x00 + memory[0xABCD + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, memory[0xABCD + mpu.X]) - assertEquals(0xFF, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0003, mpu.regPC) + assertEquals(0xFF, memory[0xABCD + mpu.regX]) + assertEquals(0xFF, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sta_abs_x_indexed_stores_a_leaves_a_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.A = 0x00 - mpu.X = 0x03 + mpu.regP.fromByte(flags) + mpu.regA = 0x00 + mpu.regX = 0x03 // $0000 STA $ABCD,X writeMem(memory, 0x0000, listOf(0x9D, 0xCD, 0xAB)) - memory[0xABCD + mpu.X] = 0xFF + memory[0xABCD + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.X]) - assertEquals(0x00, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0003, mpu.regPC) + assertEquals(0x00, memory[0xABCD + mpu.regX]) + assertEquals(0x00, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STA Absolute, Y-Indexed @@ -5602,33 +5603,33 @@ abstract class TestCommon6502 { @Test fun test_sta_abs_y_indexed_stores_a_leaves_a_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.A = 0xFF - mpu.Y = 0x03 + mpu.regP.fromByte(flags) + mpu.regA = 0xFF + mpu.regY = 0x03 // $0000 STA $ABCD,Y writeMem(memory, 0x0000, listOf(0x99, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0x00 + memory[0xABCD + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0xFF, memory[0xABCD + mpu.Y]) - assertEquals(0xFF, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0003, mpu.regPC) + assertEquals(0xFF, memory[0xABCD + mpu.regY]) + assertEquals(0xFF, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sta_abs_y_indexed_stores_a_leaves_a_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.A = 0x00 - mpu.Y = 0x03 + mpu.regP.fromByte(flags) + mpu.regA = 0x00 + mpu.regY = 0x03 // $0000 STA $ABCD,Y writeMem(memory, 0x0000, listOf(0x99, 0xCD, 0xAB)) - memory[0xABCD + mpu.Y] = 0xFF + memory[0xABCD + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) - assertEquals(0x00, memory[0xABCD + mpu.Y]) - assertEquals(0x00, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0003, mpu.regPC) + assertEquals(0x00, memory[0xABCD + mpu.regY]) + assertEquals(0x00, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STA Indirect, Indexed (X) @@ -5636,37 +5637,37 @@ abstract class TestCommon6502 { @Test fun test_sta_ind_indexed_x_stores_a_leaves_a_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.A = 0xFF - mpu.X = 0x03 + mpu.regP.fromByte(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.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0xFF, memory[0xFEED]) - assertEquals(0xFF, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0xFF, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sta_ind_indexed_x_stores_a_leaves_a_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.A = 0x00 - mpu.X = 0x03 + mpu.regP.fromByte(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.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0xFEED]) - assertEquals(0x00, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x00, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STA Indexed, Indirect (Y) @@ -5674,37 +5675,37 @@ abstract class TestCommon6502 { @Test fun test_sta_indexed_ind_y_stores_a_leaves_a_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.A = 0xFF - mpu.Y = 0x03 + mpu.regP.fromByte(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.Y] = 0x00 + memory[0xFEED + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, memory[0xFEED + mpu.Y]) - assertEquals(0xFF, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xFF, memory[0xFEED + mpu.regY]) + assertEquals(0xFF, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sta_indexed_ind_y_stores_a_leaves_a_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.A = 0x00 - mpu.Y = 0x03 + mpu.regP.fromByte(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.Y] = 0xFF + memory[0xFEED + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0xFEED + mpu.Y]) - assertEquals(0x00, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, memory[0xFEED + mpu.regY]) + assertEquals(0x00, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STA Zero Page, X-Indexed @@ -5712,33 +5713,33 @@ abstract class TestCommon6502 { @Test fun test_sta_zp_x_indexed_stores_a_leaves_a_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.A = 0xFF - mpu.X = 0x03 + mpu.regP.fromByte(flags) + mpu.regA = 0xFF + mpu.regX = 0x03 // $0000 STA $0010,X writeMem(memory, 0x0000, listOf(0x95, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, memory[0x0010 + mpu.X]) - assertEquals(0xFF, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xFF, memory[0x0010 + mpu.regX]) + assertEquals(0xFF, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sta_zp_x_indexed_stores_a_leaves_a_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.A = 0x00 - mpu.X = 0x03 + mpu.regP.fromByte(flags) + mpu.regA = 0x00 + mpu.regX = 0x03 // $0000 STA $0010,X writeMem(memory, 0x0000, listOf(0x95, 0x10)) - memory[0x0010 + mpu.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertEquals(0x00, mpu.A) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, memory[0x0010 + mpu.regX]) + assertEquals(0x00, mpu.regA) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STX Absolute @@ -5746,31 +5747,31 @@ abstract class TestCommon6502 { @Test fun test_stx_absolute_stores_x_leaves_x_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.X = 0xFF + mpu.regP.fromByte(flags) + mpu.regX = 0xFF // $0000 STX $ABCD writeMem(memory, 0x0000, listOf(0x8E, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0xFF, memory[0xABCD]) - assertEquals(0xFF, mpu.X) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0xFF, mpu.regX) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_stx_absolute_stores_x_leaves_x_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.X = 0x00 + mpu.regP.fromByte(flags) + mpu.regX = 0x00 // $0000 STX $ABCD writeMem(memory, 0x0000, listOf(0x8E, 0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertEquals(0x00, mpu.X) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x00, mpu.regX) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STX Zero Page @@ -5778,31 +5779,31 @@ abstract class TestCommon6502 { @Test fun test_stx_zp_stores_x_leaves_x_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.X = 0xFF + mpu.regP.fromByte(flags) + mpu.regX = 0xFF // $0000 STX $0010 writeMem(memory, 0x0000, listOf(0x86, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0xFF, memory[0x0010]) - assertEquals(0xFF, mpu.X) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0xFF, mpu.regX) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_stx_zp_stores_x_leaves_x_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.X = 0x00 + mpu.regP.fromByte(flags) + mpu.regX = 0x00 // $0000 STX $0010 writeMem(memory, 0x0000, listOf(0x86, 0x10)) memory[0x0010] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertEquals(0x00, mpu.X) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x00, mpu.regX) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STX Zero Page, Y-Indexed @@ -5810,33 +5811,33 @@ abstract class TestCommon6502 { @Test fun test_stx_zp_y_indexed_stores_x_leaves_x_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.X = 0xFF - mpu.Y = 0x03 + mpu.regP.fromByte(flags) + mpu.regX = 0xFF + mpu.regY = 0x03 // $0000 STX $0010,Y writeMem(memory, 0x0000, listOf(0x96, 0x10)) - memory[0x0010 + mpu.Y] = 0x00 + memory[0x0010 + mpu.regY] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, memory[0x0010 + mpu.Y]) - assertEquals(0xFF, mpu.X) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xFF, memory[0x0010 + mpu.regY]) + assertEquals(0xFF, mpu.regX) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_stx_zp_y_indexed_stores_x_leaves_x_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.X = 0x00 - mpu.Y = 0x03 + mpu.regP.fromByte(flags) + mpu.regX = 0x00 + mpu.regY = 0x03 // $0000 STX $0010,Y writeMem(memory, 0x0000, listOf(0x96, 0x10)) - memory[0x0010 + mpu.Y] = 0xFF + memory[0x0010 + mpu.regY] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.Y]) - assertEquals(0x00, mpu.X) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, memory[0x0010 + mpu.regY]) + assertEquals(0x00, mpu.regX) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STY Absolute @@ -5844,31 +5845,31 @@ abstract class TestCommon6502 { @Test fun test_sty_absolute_stores_y_leaves_y_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.Y = 0xFF + mpu.regP.fromByte(flags) + mpu.regY = 0xFF // $0000 STY $ABCD writeMem(memory, 0x0000, listOf(0x8C, 0xCD, 0xAB)) memory[0xABCD] = 0x00 mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0xFF, memory[0xABCD]) - assertEquals(0xFF, mpu.Y) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0xFF, mpu.regY) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sty_absolute_stores_y_leaves_y_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.Y = 0x00 + mpu.regP.fromByte(flags) + mpu.regY = 0x00 // $0000 STY $ABCD writeMem(memory, 0x0000, listOf(0x8C, 0xCD, 0xAB)) memory[0xABCD] = 0xFF mpu.step() - assertEquals(0x0003, mpu.PC) + assertEquals(0x0003, mpu.regPC) assertEquals(0x00, memory[0xABCD]) - assertEquals(0x00, mpu.Y) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x00, mpu.regY) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STY Zero Page @@ -5876,31 +5877,31 @@ abstract class TestCommon6502 { @Test fun test_sty_zp_stores_y_leaves_y_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.Y = 0xFF + mpu.regP.fromByte(flags) + mpu.regY = 0xFF // $0000 STY $0010 writeMem(memory, 0x0000, listOf(0x84, 0x10)) memory[0x0010] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0xFF, memory[0x0010]) - assertEquals(0xFF, mpu.Y) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0xFF, mpu.regY) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sty_zp_stores_y_leaves_y_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.Y = 0x00 + mpu.regP.fromByte(flags) + mpu.regY = 0x00 // $0000 STY $0010 writeMem(memory, 0x0000, listOf(0x84, 0x10)) memory[0x0010] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) + assertEquals(0x0002, mpu.regPC) assertEquals(0x00, memory[0x0010]) - assertEquals(0x00, mpu.Y) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x00, mpu.regY) + assertEquals(flags, mpu.regP.asByte().toInt()) } // STY Zero Page, X-Indexed @@ -5908,282 +5909,282 @@ abstract class TestCommon6502 { @Test fun test_sty_zp_x_indexed_stores_y_leaves_y_and_n_flag_unchanged() { val flags = 0xFF and fNEGATIVE.inv() - mpu.Status.fromByte(flags) - mpu.Y = 0xFF - mpu.X = 0x03 + mpu.regP.fromByte(flags) + mpu.regY = 0xFF + mpu.regX = 0x03 // $0000 STY $0010,X writeMem(memory, 0x0000, listOf(0x94, 0x10)) - memory[0x0010 + mpu.X] = 0x00 + memory[0x0010 + mpu.regX] = 0x00 mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0xFF, memory[0x0010 + mpu.X]) - assertEquals(0xFF, mpu.Y) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0002, mpu.regPC) + assertEquals(0xFF, memory[0x0010 + mpu.regX]) + assertEquals(0xFF, mpu.regY) + assertEquals(flags, mpu.regP.asByte().toInt()) } @Test fun test_sty_zp_x_indexed_stores_y_leaves_y_and_z_flag_unchanged() { val flags = 0xFF and fZERO.inv() - mpu.Status.fromByte(flags) - mpu.Y = 0x00 - mpu.X = 0x03 + mpu.regP.fromByte(flags) + mpu.regY = 0x00 + mpu.regX = 0x03 // $0000 STY $0010,X writeMem(memory, 0x0000, listOf(0x94, 0x10)) - memory[0x0010 + mpu.X] = 0xFF + memory[0x0010 + mpu.regX] = 0xFF mpu.step() - assertEquals(0x0002, mpu.PC) - assertEquals(0x00, memory[0x0010 + mpu.X]) - assertEquals(0x00, mpu.Y) - assertEquals(flags, mpu.Status.asByte().toInt()) + assertEquals(0x0002, mpu.regPC) + assertEquals(0x00, memory[0x0010 + mpu.regX]) + assertEquals(0x00, mpu.regY) + assertEquals(flags, mpu.regP.asByte().toInt()) } // TAX @Test fun test_tax_transfers_accumulator_into_x() { - mpu.A = 0xAB - mpu.X = 0x00 + mpu.regA = 0xAB + mpu.regX = 0x00 // $0000 TAX memory[0x0000] = 0xAA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.A) - assertEquals(0xAB, mpu.X) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regA) + assertEquals(0xAB, mpu.regX) } @Test fun test_tax_sets_negative_flag() { - mpu.Status.N = false - mpu.A = 0x80 - mpu.X = 0x00 + mpu.regP.N = false + mpu.regA = 0x80 + mpu.regX = 0x00 // $0000 TAX memory[0x0000] = 0xAA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.A) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x80, mpu.regA) + assertEquals(0x80, mpu.regX) + assertTrue(mpu.regP.N) } @Test fun test_tax_sets_zero_flag() { - mpu.Status.Z = false - mpu.A = 0x00 - mpu.X = 0xFF + mpu.regP.Z = false + mpu.regA = 0x00 + mpu.regX = 0xFF // $0000 TAX memory[0x0000] = 0xAA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) + 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.A = 0xAB - mpu.Y = 0x00 + mpu.regA = 0xAB + mpu.regY = 0x00 // $0000 TAY memory[0x0000] = 0xA8 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.A) - assertEquals(0xAB, mpu.Y) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regA) + assertEquals(0xAB, mpu.regY) } @Test fun test_tay_sets_negative_flag() { - mpu.Status.N = false - mpu.A = 0x80 - mpu.Y = 0x00 + mpu.regP.N = false + mpu.regA = 0x80 + mpu.regY = 0x00 // $0000 TAY memory[0x0000] = 0xA8 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.A) - assertEquals(0x80, mpu.Y) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x80, mpu.regA) + assertEquals(0x80, mpu.regY) + assertTrue(mpu.regP.N) } @Test fun test_tay_sets_zero_flag() { - mpu.Status.Z = false - mpu.A = 0x00 - mpu.Y = 0xFF + mpu.regP.Z = false + mpu.regA = 0x00 + mpu.regY = 0xFF // $0000 TAY memory[0x0000] = 0xA8 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) + 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.SP = 0xAB - mpu.X = 0x00 + mpu.regSP = 0xAB + mpu.regX = 0x00 // $0000 TSX memory[0x0000] = 0xBA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.SP) - assertEquals(0xAB, mpu.X) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regSP) + assertEquals(0xAB, mpu.regX) } @Test fun test_tsx_sets_negative_flag() { - mpu.Status.N = false - mpu.SP = 0x80 - mpu.X = 0x00 + mpu.regP.N = false + mpu.regSP = 0x80 + mpu.regX = 0x00 // $0000 TSX memory[0x0000] = 0xBA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.SP) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x80, mpu.regSP) + assertEquals(0x80, mpu.regX) + assertTrue(mpu.regP.N) } @Test fun test_tsx_sets_zero_flag() { - mpu.Status.Z = false - mpu.SP = 0x00 - mpu.Y = 0xFF + mpu.regP.Z = false + mpu.regSP = 0x00 + mpu.regY = 0xFF // $0000 TSX memory[0x0000] = 0xBA mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.SP) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) + 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.X = 0xAB - mpu.A = 0x00 + mpu.regX = 0xAB + mpu.regA = 0x00 // $0000 TXA memory[0x0000] = 0x8A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.A) - assertEquals(0xAB, mpu.X) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regA) + assertEquals(0xAB, mpu.regX) } @Test fun test_txa_sets_negative_flag() { - mpu.Status.N = false - mpu.X = 0x80 - mpu.A = 0x00 + mpu.regP.N = false + mpu.regX = 0x80 + mpu.regA = 0x00 // $0000 TXA memory[0x0000] = 0x8A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.A) - assertEquals(0x80, mpu.X) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x80, mpu.regA) + assertEquals(0x80, mpu.regX) + assertTrue(mpu.regP.N) } @Test fun test_txa_sets_zero_flag() { - mpu.Status.Z = false - mpu.X = 0x00 - mpu.A = 0xFF + mpu.regP.Z = false + mpu.regX = 0x00 + mpu.regA = 0xFF // $0000 TXA memory[0x0000] = 0x8A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.A) - assertEquals(0x00, mpu.X) - assertTrue(mpu.Status.Z) + 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.X = 0xAB + mpu.regX = 0xAB // $0000 TXS memory[0x0000] = 0x9A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.SP) - assertEquals(0xAB, mpu.X) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regSP) + assertEquals(0xAB, mpu.regX) } @Test fun test_txs_does_not_set_negative_flag() { - mpu.Status.N = false - mpu.X = 0x80 + mpu.regP.N = false + mpu.regX = 0x80 // $0000 TXS memory[0x0000] = 0x9A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.SP) - assertEquals(0x80, mpu.X) - assertFalse(mpu.Status.N) + 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.Status.Z = false - mpu.X = 0x00 + mpu.regP.Z = false + mpu.regX = 0x00 // $0000 TXS memory[0x0000] = 0x9A mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x00, mpu.SP) - assertEquals(0x00, mpu.X) - assertFalse(mpu.Status.Z) + 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.Y = 0xAB - mpu.A = 0x00 + mpu.regY = 0xAB + mpu.regA = 0x00 // $0000 TYA memory[0x0000] = 0x98 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0xAB, mpu.A) - assertEquals(0xAB, mpu.Y) + assertEquals(0x0001, mpu.regPC) + assertEquals(0xAB, mpu.regA) + assertEquals(0xAB, mpu.regY) } @Test fun test_tya_sets_negative_flag() { - mpu.Status.N = false - mpu.Y = 0x80 - mpu.A = 0x00 + mpu.regP.N = false + mpu.regY = 0x80 + mpu.regA = 0x00 // $0000 TYA memory[0x0000] = 0x98 mpu.step() - assertEquals(0x0001, mpu.PC) - assertEquals(0x80, mpu.A) - assertEquals(0x80, mpu.Y) - assertTrue(mpu.Status.N) + assertEquals(0x0001, mpu.regPC) + assertEquals(0x80, mpu.regA) + assertEquals(0x80, mpu.regY) + assertTrue(mpu.regP.N) } @Test fun test_tya_sets_zero_flag() { - mpu.Status.Z = false - mpu.Y = 0x00 - mpu.A = 0xFF + mpu.regP.Z = false + mpu.regY = 0x00 + mpu.regA = 0xFF // $0000 TYA memory[0x0000] = 0x98 mpu.step() - assertEquals(0x00, mpu.A) - assertEquals(0x00, mpu.Y) - assertTrue(mpu.Status.Z) - assertEquals(0x0001, mpu.PC) + assertEquals(0x00, mpu.regA) + assertEquals(0x00, mpu.regY) + assertTrue(mpu.regP.Z) + assertEquals(0x0001, mpu.regPC) } @Test @@ -6199,21 +6200,21 @@ abstract class TestCommon6502 { 0x40)) // RTI mpu.step() // LDA #$01 - assertEquals(0x01, mpu.A) - assertEquals(0x0002, mpu.PC) + assertEquals(0x01, mpu.regA) + assertEquals(0x0002, mpu.regPC) mpu.step() // BRK - assertEquals(0x0400, mpu.PC) + assertEquals(0x0400, mpu.regPC) mpu.step() // LDA #$02 - assertEquals(0x02, mpu.A) - assertEquals(0x0402, mpu.PC) + assertEquals(0x02, mpu.regA) + assertEquals(0x0402, mpu.regPC) mpu.step() // RTI - assertEquals(0x0004, mpu.PC) + assertEquals(0x0004, mpu.regPC) mpu.step() // A NOP mpu.step() // The second NOP mpu.step() // LDA #$03 - assertEquals(0x03, mpu.A) - assertEquals(0x0008, mpu.PC) + assertEquals(0x03, mpu.regA) + assertEquals(0x0008, mpu.regPC) } } diff --git a/src/test/kotlin/TestDisassembler.kt b/src/test/kotlin/TestDisassembler.kt index 80dcc8f..c362765 100644 --- a/src/test/kotlin/TestDisassembler.kt +++ b/src/test/kotlin/TestDisassembler.kt @@ -1,5 +1,5 @@ -import razorvine.ksim65.components.Cpu6502 -import razorvine.ksim65.components.Cpu65C02 +import razorvine.ksim65.Cpu6502 +import razorvine.ksim65.Cpu65C02 import razorvine.ksim65.components.Ram import kotlin.test.*