tests: add test for outfmt

Author: boriel

tests/outfmt/__init__.py

@@ -0,0 +1,27 @@
+# --------------------------------------------------------------------
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# © Copyright 2008-2024 José Manuel Rodríguez de la Rosa and contributors.
+# See the file CONTRIBUTORS.md for copyright details.
+# See https://www.gnu.org/licenses/agpl-3.0.html for details.
+# --------------------------------------------------------------------
+
+from src.outfmt.binary import BinaryEmitter
+
+
+def test_binary_emitter(tmp_path):
+    output_file = tmp_path / "test.bin"
+    emitter = BinaryEmitter()
+    program_bytes = b"\x01\x02\x03\x04"
+
+    emitter.emit(
+        output_filename=str(output_file),
+        program_name="test",
+        loader_bytes=None,
+        entry_point=16384,
+        program_bytes=program_bytes,
+        aux_bin_blocks=[],
+        aux_headless_bin_blocks=[],
+    )
+
+    assert output_file.exists()
+    assert output_file.read_bytes() == program_bytes

tests/outfmt/test_binary.py

@@ -0,0 +1,57 @@
+# --------------------------------------------------------------------
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# © Copyright 2008-2024 José Manuel Rodríguez de la Rosa and contributors.
+# See the file CONTRIBUTORS.md for copyright details.
+# See https://www.gnu.org/licenses/agpl-3.0.html for details.
+# --------------------------------------------------------------------
+
+from src.outfmt.sna import SnaEmitter
+
+
+def test_sna_emitter_generate():
+    emitter = SnaEmitter()
+    program_bytes = b"\x00" * 100
+    entry_point = 0x8000
+
+    # generate(self, loader_bytes, clear_addr, entry_point, program_bytes)
+    # SnaEmitter.emit calls generate(None, entry_point - 1, entry_point, program_bytes)
+    sna_data = emitter.generate(None, entry_point - 1, entry_point, program_bytes)
+
+    assert len(sna_data) == 27 + 49152
+
+    # Check some header values
+    # snapshot.I is initialized to 0x3F in GenSnapshot
+    assert sna_data[0] == 0x3F
+
+    # Border color (snapshot.outFE & 7)
+    # GenSnapshot.outFE = 0x0F, so 0x0F & 7 = 7
+    assert sna_data[26] == 7
+
+    # Check SP
+    # GenSnapshot: SP = clear_addr - 3 = (0x8000 - 1) - 3 = 0x7FFC = 32764
+    # SnaEmitter: SP = snapshot.SP - 2 = 32764 - 2 = 32762 (0x7FFA)
+    # sna_data[23] = 0xFA, sna_data[24] = 0x7F
+    assert sna_data[23] == 0xFA
+    assert sna_data[24] == 0x7F
+
+    # Check PC patched on stack
+    # snapshot.PCL = 0x9E, snapshot.PCH = 0x1B
+    # Index in sna_data = 27 + 32762 - 16384 = 16405
+    assert sna_data[27 + 32762 - 16384] == 0x9E
+    assert sna_data[27 + 32762 - 16384 + 1] == 0x1B
+
+
+def test_sna_emitter_emit(tmp_path):
+    output_file = tmp_path / "test.sna"
+    emitter = SnaEmitter()
+    emitter.emit(
+        output_filename=str(output_file),
+        program_name="test",
+        loader_bytes=None,
+        entry_point=0x8000,
+        program_bytes=b"\x00" * 100,
+        aux_bin_blocks=[],
+        aux_headless_bin_blocks=[],
+    )
+    assert output_file.exists()
+    assert len(output_file.read_bytes()) == 27 + 49152

tests/outfmt/test_sna.py

@@ -0,0 +1,63 @@
+# --------------------------------------------------------------------
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# © Copyright 2008-2024 José Manuel Rodríguez de la Rosa and contributors.
+# See the file CONTRIBUTORS.md for copyright details.
+# See https://www.gnu.org/licenses/agpl-3.0.html for details.
+# --------------------------------------------------------------------
+
+from src.outfmt.tap import TAP
+
+
+def test_tap_init():
+    tap = TAP()
+    assert tap.output == b""
+
+
+def test_tap_standard_block():
+    tap = TAP()
+    tap.standard_block(b"\x01\x02")
+    # Length (3 -> [0x03, 0x00])
+    # Data: \x01\x02
+    # Checksum: 0x01 ^ 0x02 = 0x03
+    assert tap.output == b"\x03\x00\x01\x02\x03"
+
+
+def test_tap_emit(tmp_path):
+    output_file = tmp_path / "test.tap"
+    tap = TAP()
+    program_bytes = b"\x00\x01"
+    tap.emit(
+        output_filename=str(output_file),
+        program_name="test",
+        loader_bytes=None,
+        entry_point=16384,
+        program_bytes=program_bytes,
+        aux_bin_blocks=[],
+        aux_headless_bin_blocks=[],
+    )
+    assert output_file.exists()
+    content = output_file.read_bytes()
+
+    # Header block
+    # 0x13 0x00 (Length)
+    # 0x00 (BLOCK_TYPE_HEADER)
+    # 0x03 (HEADER_TYPE_CODE)
+    # "test      " (10 bytes)
+    # 0x02 0x00 (Length 2)
+    # 0x00 0x40 (Address 16384)
+    # 0x00 0x80 (32768)
+    # Checksum
+    expected_header_content = b"\x00\x03test      \x02\x00\x00\x40\x00\x80"
+    checksum = 0
+    for b in expected_header_content:
+        checksum ^= b
+    expected_header = b"\x13\x00" + expected_header_content + bytes([checksum])
+    assert content.startswith(expected_header)
+
+    # Data block
+    # 0x04 0x00 (Length)
+    # 0xFF (BLOCK_TYPE_DATA)
+    # 0x00 0x01 (data)
+    # Checksum: 0xFF ^ 0x00 ^ 0x01 = 0xFE
+    expected_data = b"\x04\x00\xff\x00\x01\xfe"
+    assert expected_data in content

tests/outfmt/test_tap.py

@@ -0,0 +1,77 @@
+# --------------------------------------------------------------------
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# © Copyright 2008-2024 José Manuel Rodríguez de la Rosa and contributors.
+# See the file CONTRIBUTORS.md for copyright details.
+# See https://www.gnu.org/licenses/agpl-3.0.html for details.
+# --------------------------------------------------------------------
+
+from src.outfmt.tzx import TZX
+
+
+def test_tzx_init():
+    tzx = TZX()
+    assert tzx.output == b"ZXTape!\x1a\x01\x15"
+
+
+def test_tzx_lh():
+    tzx = TZX()
+    assert tzx.LH(0x1234) == [0x34, 0x12]
+    assert tzx.LH(0x00FF) == [0xFF, 0x00]
+
+
+def test_tzx_standard_block():
+    tzx = TZX()
+    tzx.output = bytearray()
+    tzx.standard_block(b"\x01\x02")
+    # BLOCK_STANDARD (0x10)
+    # Pause (1000ms -> [0xE8, 0x03])
+    # Length (3 -> [0x03, 0x00]) - length of data + 1 for checksum
+    # Data: \x01\x02
+    # Checksum: 0x01 ^ 0x02 = 0x03
+    assert tzx.output == b"\x10\xe8\x03\x03\x00\x01\x02\x03"
+
+
+def test_tzx_emit(tmp_path):
+    output_file = tmp_path / "test.tzx"
+    tzx = TZX()
+    program_bytes = b"\x00\x01"
+    tzx.emit(
+        output_filename=str(output_file),
+        program_name="test",
+        loader_bytes=None,
+        entry_point=16384,
+        program_bytes=program_bytes,
+        aux_bin_blocks=[],
+        aux_headless_bin_blocks=[],
+    )
+    assert output_file.exists()
+    content = output_file.read_bytes()
+    assert content.startswith(b"ZXTape!\x1a\x01\x15")
+
+    # Header block for "test"
+    # 0x10 (Standard block ID)
+    # 0xE8 0x03 (1000ms pause)
+    # 0x13 0x00 (Length of header: 1 + 1 + 10 + 2 + 2 + 2 + 1 = 19 -> 0x13)
+    # 0x00 (BLOCK_TYPE_HEADER)
+    # 0x03 (HEADER_TYPE_CODE)
+    # "test      " (10 bytes)
+    # 0x02 0x00 (Length 2)
+    # 0x00 0x40 (Address 16384)
+    # 0x00 0x80 (32768)
+    # Checksum (XOR of all bytes in block)
+    expected_header_content = b"\x00\x03test      \x02\x00\x00\x40\x00\x80"
+    checksum = 0
+    for b in expected_header_content:
+        checksum ^= b
+    expected_header_block = b"\x10\xe8\x03\x13\x00" + expected_header_content + bytes([checksum])
+    assert expected_header_block in content
+
+    # Data block
+    # 0x10
+    # 0xE8 0x03
+    # 0x04 0x00 (Length of data: 1 (type) + 2 (bytes) + 1 (checksum) = 4)
+    # 0xFF (BLOCK_TYPE_DATA)
+    # 0x00 0x01 (data)
+    # Checksum: 0xFF ^ 0x00 ^ 0x01 = 0xFE
+    expected_data_block = b"\x10\xe8\x03\x04\x00\xff\x00\x01\xfe"
+    assert expected_data_block in content

tests/outfmt/test_tzx.py

@@ -0,0 +1,57 @@
+# --------------------------------------------------------------------
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# © Copyright 2008-2024 José Manuel Rodríguez de la Rosa and contributors.
+# See the file CONTRIBUTORS.md for copyright details.
+# See https://www.gnu.org/licenses/agpl-3.0.html for details.
+# --------------------------------------------------------------------
+
+from src.outfmt.z80 import Z80Emitter
+
+
+def test_z80_emitter_generate():
+    emitter = Z80Emitter()
+    program_bytes = b"\x00" * 100
+    entry_point = 0x8000
+
+    # generate(self, loader_bytes, clear_addr, entry_point, program_bytes)
+    z80_data = emitter.generate(None, entry_point - 1, entry_point, program_bytes)
+
+    # Header is 30 bytes
+    assert len(z80_data) > 30
+    assert z80_data[10] == 0x3F  # snapshot.I
+
+    # PC in Z80 version 1 header at offset 6
+    # GenSnapshot default PC is 0x1B9E -> PCL=0x9E, PCH=0x1B
+    assert z80_data[6] == 0x9E
+    assert z80_data[7] == 0x1B
+
+    # End marker
+    assert z80_data.endswith(b"\x00\xed\xed\x00")
+
+
+def test_z80_compression():
+    emitter = Z80Emitter()
+
+    # program_bytes with 4 EDs to test compression
+    program_bytes = b"\xed\xed\xed\xed"
+    entry_point = 0x8000
+
+    z80_data = emitter.generate(None, entry_point - 1, entry_point, program_bytes)
+
+    # The 4 EDs should be compressed to ED ED 04 ED
+    assert b"\xed\xed\x04\xed" in z80_data
+
+
+def test_z80_emitter_emit(tmp_path):
+    output_file = tmp_path / "test.z80"
+    emitter = Z80Emitter()
+    emitter.emit(
+        output_filename=str(output_file),
+        program_name="test",
+        loader_bytes=None,
+        entry_point=0x8000,
+        program_bytes=b"\x00" * 100,
+        aux_bin_blocks=[],
+        aux_headless_bin_blocks=[],
+    )
+    assert output_file.exists()