006. FakeROM

Crear un almacenamiento FakeROM escribible para los tests de la CPU.

Lección 6 de 356 · tests/chapter_01_cpu/test_006_FakeROM.py

Archivo a crear

emulator/memory/fake_rom.py

Ubicación

class FakeROM(MemoryDevice)

Por qué existe este paso

Los tests de instrucciones necesitan bytes de programa deterministas antes de disponer del análisis real de cartuchos. FakeROM modela la ventana PRG máxima $8000-$FFFF como 0x8000 bytes locales y permite que los tests la rellenen directamente.

Implementación de ejemplo completa

from dataclasses import dataclass, field

from emulator.memory.memory_device import MemoryDevice


@dataclass
class FakeROM(MemoryDevice):
    _data: bytearray = field(
        default_factory=lambda: bytearray(0x8000),
        init=False,
    )

    def read(self, addr: int) -> int:
        return self._data[addr]

    def write(self, addr: int, value: int) -> None:
        self._data[addr] = value

Invariantes importantes

FakeROM almacena exactamente 0x8000 bytes
sus direcciones son desplazamientos locales $0000-$7FFF
las escrituras existen solo para preparar programas y datos de prueba

Error común

FakeROM no es un mapeador de cartucho real y su método de escritura no implica que la ROM PRG de la NES sea escribible. Es infraestructura de test controlada.

Fuera de alcance

mapear FakeROM en las direcciones de la CPU
análisis de iNES
conmutación de bancos

Ejecutar esta lección

uv run pytest tests/chapter_01_cpu/test_006_FakeROM.py -v

Implementación de ejemplo

Implementación de ejemplo completa

from dataclasses import dataclass, field

from emulator.memory.memory_device import MemoryDevice


@dataclass
class FakeROM(MemoryDevice):
    _data: bytearray = field(
        default_factory=lambda: bytearray(0x8000),
        init=False,
    )

    def read(self, addr: int) -> int:
        return self._data[addr]

    def write(self, addr: int, value: int) -> None:
        self._data[addr] = value

Ver código del testtest_006_FakeROM.py

from pathlib import Path
from emulator.memory.memory_device import MemoryDevice

def test_program_rom_class_exists():
    """
    We are going to create a Fake ROM for testing purposes
    It does not have any logic about how real cartridges work
    """
    assert Path("emulator/memory/fake_rom.py").exists()

def test_fake_rom_uses_memory_device_abstract_class():
    """
    Create a new FakeROM class inside fake_rom.py
    Ensure that it uses our abstract class MemoryDevice
    The methods read/write can be void on this test, just declare it
    """

    from emulator.memory.fake_rom import FakeROM

    assert FakeROM is not None

    rom = FakeROM()
    assert isinstance(rom, MemoryDevice)

def test_fake_rom_has_0x8000_bytes():
    """
    The CPU address range $8000-$FFFF is commonly used for PRG ROM.

    Look at: https://en.wikibooks.org/wiki/NES_Programming/Memory_Map
    NES has 2 Possible ROM Addresses 0x8000 and 0xC000

    Each one of 0x4000 Size, then the max size is 0x8000 [0x0000-0x7FFF]
    Lets implement a _data = bytearray(0x8000) inside our Fake ROM

    """

    from emulator.memory.fake_rom import FakeROM
    rom = FakeROM()
    assert hasattr(rom, "_data")
    assert isinstance(rom._data, bytearray)
    assert len(rom._data) == 0x8000

def test_write_read_fake_rom():
    """
    Remember: a real ROM will never implement Write methods,
    Our Fake ROM is for testing purposes and that's why we implement write
    """
    from emulator.memory.fake_rom import FakeROM
    fake_rom = FakeROM()

    for addr in range(0x0, 0x8000):
        test_value = addr & 0xFF

        fake_rom.write(addr, test_value)

        assert fake_rom.read(addr) == test_value

Funciones de test (4)

test_program_rom_class_exists
test_fake_rom_uses_memory_device_abstract_class
test_fake_rom_has_0x8000_bytes
test_write_read_fake_rom