Publish the reproducible Sound Lab and FPGA Colour Lab sources

This commit is contained in:
bholman committed 2026-11-18 12:28:31 -07:00
commit 88254d7e24
27 files changed
+4574

No files matched your search

+169
View File
@@ -0,0 +1,169 @@
# SPDX-License-Identifier: GPL-3.0-or-later
"""Authored PCM fixtures; no ROMs, hardware, dependencies or listening claims."""
import hashlib
import importlib.util
import json
import math
from pathlib import Path
import struct
import subprocess
import sys
import tempfile
import unittest
import wave
SCRIPT = Path(__file__).resolve().parents[1] / "audio" / "analyze.py"
SPEC = importlib.util.spec_from_file_location("sound_lab_audio", SCRIPT)
audio = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(audio)
class AudioTests(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory(prefix="soundlab-audio-")
self.addCleanup(self.temporary.cleanup)
self.directory = Path(self.temporary.name)
def wav(self, channels, rate=48000, width=2):
path = self.directory / "capture.wav"
payload = bytearray()
for frame in zip(*channels):
for value in frame:
payload.extend((value + 128 if width == 1 else value).to_bytes(width, "little", signed=width != 1))
with wave.open(str(path), "wb") as output:
output.setnchannels(len(channels))
output.setsampwidth(width)
output.setframerate(rate)
output.writeframes(payload)
return path
def manifest(self, duration=1, **kwargs):
segment = dict(case_id="AUTHORED", kind="tone", start_seconds=0, end_seconds=duration)
segment.update(kwargs)
path = self.directory / "intervals.json"
path.write_text(json.dumps({"segments": [segment]}))
return path
def sine(self, rate, hz, amplitude=16384):
return [round(amplitude * math.sin(2 * math.pi * hz * index / rate)) for index in range(rate)]
def test_tone_both_sample_rates_and_input_hashes(self):
for rate in (44100, 48000):
with self.subTest(rate=rate):
wav = self.wav([self.sine(rate, 440)], rate)
manifest = self.manifest(nominal_hz=440)
original = wav.read_bytes()
report = audio.analyze(wav, manifest)
channel = report["segments"][0]["channels"][0]
self.assertEqual(report["capture"]["sample_rate_hz"], rate)
self.assertAlmostEqual(channel["frequency"]["estimated_hz"], 440, delta=0.02)
self.assertAlmostEqual(channel["rms_full_scale"], 0.5 / math.sqrt(2), delta=0.0001)
self.assertEqual(report["capture"]["sha256"], hashlib.sha256(original).hexdigest())
self.assertEqual(wav.read_bytes(), original)
self.assertEqual(report["human_status"], "NOT_OBSERVED")
self.assertEqual(channel["assessment"], "MEASURE_BASELINE")
def test_silence_and_rails(self):
wav = self.wav([[0] * 48000])
report = audio.analyze(wav, self.manifest(kind="silence"))
channel = report["segments"][0]["channels"][0]
self.assertEqual(channel["rms_full_scale"], 0)
self.assertEqual(channel["near_zero_ratio"], 1)
self.assertNotIn("frequency", channel)
wav = self.wav([[-32768, 32767, 0, 1]])
channel = audio.analyze(wav, self.manifest(duration=4 / 48000, kind="noise"))["segments"][0]["channels"][0]
self.assertEqual(channel["clipping_count"], 2)
self.assertEqual(channel["peak_full_scale"], 1)
self.assertEqual(channel["near_zero_ratio"], 0.5)
def test_stereo_keeps_different_channels(self):
wav = self.wav([self.sine(48000, 440), self.sine(48000, 880, 8192)])
channels = audio.analyze(wav, self.manifest())["segments"][0]["channels"]
self.assertAlmostEqual(channels[0]["frequency"]["estimated_hz"], 440, delta=0.02)
self.assertAlmostEqual(channels[1]["frequency"]["estimated_hz"], 880, delta=0.02)
self.assertAlmostEqual(channels[0]["rms_full_scale"] / channels[1]["rms_full_scale"], 2, delta=0.001)
def test_supported_integer_widths(self):
for width in (1, 2, 3, 4):
with self.subTest(width=width):
wav = self.wav([[0, 1, -1, 2]], width=width)
report = audio.analyze(wav, self.manifest(duration=4 / 48000, kind="silence"))
self.assertEqual(report["capture"]["bit_depth"], width * 8)
self.assertEqual(report["segments"][0]["channels"][0]["near_zero_ratio"], 0.75)
def test_interval_validation_and_rounding(self):
wav = self.wav([[0] * 48000])
for kwargs in ({"start_seconds": -1}, {"end_seconds": 2}, {"end_seconds": 0},
{"start_seconds": 0.5, "end_seconds": 0.4}, {"start_seconds": float("nan")},
{"kind": "unknown"}, {"end_seconds": True}, {"case_id": ""},
{"start_seconds": 0.000001, "end_seconds": 0.000002}):
with self.subTest(kwargs=kwargs):
with self.assertRaises(ValueError):
audio.analyze(wav, self.manifest(**kwargs))
report = audio.analyze(wav, self.manifest(start_seconds=0.00001, end_seconds=0.00005))
self.assertEqual(report["segments"][0]["start_frame"], 1)
self.assertEqual(report["segments"][0]["stop_frame"], 3)
self.assertEqual(report["segments"][0]["byte_offset_in_pcm_payload"], 2)
def test_compression_float_width_and_truncation_rejected(self):
wav = self.wav([[0] * 48])
original = wav.read_bytes()
for format_tag, bits, block_align in ((6, 16, 2), (3, 32, 4), (1, 40, 5)):
with self.subTest(format_tag=format_tag, bits=bits):
damaged = bytearray(original)
struct.pack_into("<H", damaged, 20, format_tag)
struct.pack_into("<H", damaged, 34, bits)
struct.pack_into("<H", damaged, 32, block_align)
wav.write_bytes(damaged)
with self.assertRaises(ValueError):
audio.load_pcm(wav)
wav.write_bytes(original[:-5])
with self.assertRaises(ValueError):
audio.load_pcm(wav)
def test_explicit_tolerance_and_no_inferred_listening(self):
wav = self.wav([self.sine(48000, 440)])
tolerance = {"absolute_hz": 1, "qualification": "Authored digital fixture; known sample rate"}
report = audio.analyze(wav, self.manifest(nominal_hz=440, frequency_tolerance=tolerance))
self.assertEqual(report["segments"][0]["channels"][0]["assessment"], "WITHIN_QUALIFIED_TOLERANCE")
report = audio.analyze(wav, self.manifest(nominal_hz=450, frequency_tolerance=tolerance))
self.assertEqual(report["segments"][0]["channels"][0]["assessment"], "OUTSIDE_QUALIFIED_TOLERANCE")
self.assertEqual(report["assessment"], "MEASURE_BASELINE")
with self.assertRaises(ValueError):
audio.analyze(wav, self.manifest(nominal_hz=440, frequency_tolerance={"absolute_hz": 1}))
wav = self.wav([[0] * 48000])
channel = audio.analyze(wav, self.manifest())["segments"][0]["channels"][0]
self.assertIsNone(channel["frequency"]["estimated_hz"])
def test_repeated_comparison_requires_both_identities(self):
wav = self.wav([self.sine(48000, 440)])
manifest = self.manifest(vector_id="VECTOR-A")
first = json.loads(manifest.read_text())["segments"][0]
cases = [first, dict(first), dict(first, vector_id="VECTOR-B"),
dict(first, case_id="OTHER"), {k: v for k, v in first.items() if k != "vector_id"}]
manifest.write_text(json.dumps(cases))
comparisons = audio.analyze(wav, manifest)["repeated_cases"]
self.assertEqual(len(comparisons), 1)
self.assertEqual(comparisons[0]["observed_segment_index"], 1)
self.assertEqual(comparisons[0]["assessment"], "OBSERVED")
def test_cli_protects_existing_reports_and_inputs(self):
wav = self.wav([[0] * 48])
manifest = self.manifest(duration=0.001)
output = self.directory / "report.json"
command = [sys.executable, str(SCRIPT), str(wav), str(manifest), "--output", str(output)]
result = subprocess.run(command, capture_output=True)
self.assertEqual(result.returncode, 0, result.stderr)
original_report = output.read_bytes()
self.assertEqual(subprocess.run(command, capture_output=True).returncode, 2)
self.assertEqual(output.read_bytes(), original_report)
self.assertEqual(subprocess.run(command + ["--overwrite"], capture_output=True).returncode, 0)
original = wav.read_bytes()
self.assertEqual(subprocess.run(command[:-1] + [str(wav), "--overwrite"], capture_output=True).returncode, 2)
self.assertEqual(wav.read_bytes(), original)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,113 @@
# SPDX-License-Identifier: GPL-3.0-or-later
"""Authored integration fixtures for post-native Sound Lab report qualification."""
import contextlib
import importlib.util
import io
import json
from pathlib import Path
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
def load(name, path):
spec = importlib.util.spec_from_file_location(name, path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
fixture = load('soundlab_report_fixtures', ROOT / 'tests' / 'test_reports.py')
verify = load('soundlab_verify_reports', ROOT / 'verify_reports.py')
def run_text(number=1, human='UNSURE'):
text = fixture.make_report(human='NOT_OBSERVED', ending=False).decode('ascii')
header, body = text.split('CASE=', 1)
header = header.replace('RUN=0001', f'RUN={number:04d}')
case0 = 'CASE=' + body.replace('ENDCASE=', 'REPEAT=0\r\nNOTE_LENGTH=0\r\nNOTE=\r\nENDCASE=')
case1 = case0.replace('REPEAT=0', 'REPEAT=1').replace('HUMAN=NOT_OBSERVED', 'HUMAN=' + human)
text = header + case0 + case1
raw = text.encode('ascii')
footer = f'ENDRUN={number:04d} COMPLETE=YES RECORD_COUNT={len(text.splitlines())} CHECKSUM_CRC16={verify.reports.crc16(raw):04X}\r\n'
return raw + footer.encode('ascii')
def setup_build(root, *, bad_human=False, changed_binary=False, retained_changed=False):
(root / 'qualification').mkdir()
binary = b'Authored loader fixture; not executable.'
basic_source = b'10 PRINT "FIXTURE"\n'
basic_disk = b'\r' + basic_source.replace(b'\n', b'\r')
pristine = [('SOUNDLAB.BIN', binary, [0]), ('SOUNDLAB.BAS', basic_disk, [1])]
(root / 'SOUNDLAB.BIN').write_bytes(binary)
(root / 'SOUNDLAB.BAS').write_bytes(basic_source)
(root / 'SOUNDLAB.DSK').write_bytes(fixture.make_disk(pristine))
manifest = {'build_id': 'TEST-1', 'vector_set_crc16': '1234', 'vectors': [{'case_id': 'TON01-A', 'crc16': '7ABC'}], 'artifacts': []}
for name in ('SOUNDLAB.BIN', 'SOUNDLAB.BAS', 'SOUNDLAB.DSK'):
data = (root / name).read_bytes()
manifest['artifacts'].append({'filename': name, 'bytes': len(data), 'sha256': verify.sha256(data)})
(root / 'SOUNDLAB-manifest.json').write_text(json.dumps(manifest))
for label in ('6809', '6309', 'engineering'):
files = list(pristine)
if changed_binary and label == '6309':
files[0] = ('SOUNDLAB.BIN', b'Changed fixture', [0])
text = run_text(human='HEARD' if bad_human and label == '6309' else 'UNSURE')
if retained_changed and label == 'engineering':
text = text.replace(b'HUMAN=UNSURE', b'HUMAN=NO_SOUND')
# Restore valid footer so preservation is independently tested.
text = text.split(b'ENDRUN=')[0]
text += f'ENDRUN=0001 COMPLETE=YES RECORD_COUNT={len(text.splitlines())} CHECKSUM_CRC16={verify.reports.crc16(text):04X}\r\n'.encode()
files.append(('SND0001.TXT', text, [2]))
if label == 'engineering':
files.append(('SND0002.TXT', run_text(2), [3]))
(root / 'qualification' / f'{label}-reports.dsk').write_bytes(fixture.make_disk(files))
class GuestContractTests(unittest.TestCase):
def test_complete_native_contract_preserves_sources(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
setup_build(root)
inputs = {path: path.read_bytes() for path in root.rglob('*') if path.is_file()}
result = verify.qualify(root)
self.assertTrue(result['passed'])
self.assertTrue(result['engineering_original_reports_byte_identical'])
self.assertEqual(result['engineering_new_reports'], ['SND0002.TXT'])
self.assertTrue(all(run['repeat_observed'] and run['unsure_recorded'] for run in result['runs'].values()))
self.assertEqual(inputs, {path: path.read_bytes() for path in inputs})
def test_native_contract_rejects_fabricated_heard(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
setup_build(root, bad_human=True)
with self.assertRaisesRegex(verify.reports.SoundLabError, 'fabricate HUMAN=HEARD'):
verify.qualify(root)
def test_native_contract_rejects_changed_binary(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
setup_build(root, changed_binary=True)
with self.assertRaisesRegex(verify.reports.SoundLabError, 'SOUNDLAB.BIN missing or changed'):
verify.qualify(root)
def test_native_contract_rejects_changed_retained_report(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
setup_build(root, retained_changed=True)
with self.assertRaisesRegex(verify.reports.SoundLabError, 'modified or removed original 6809 report'):
verify.qualify(root)
def test_optional_receipt_never_implicitly_replaces_existing_output(self):
with tempfile.TemporaryDirectory() as directory, contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
root = Path(directory)
setup_build(root)
receipt = root / 'receipt.json'
args = ['--build-dir', str(root), '--receipt', str(receipt)]
self.assertEqual(verify.main(args), 0)
self.assertEqual(verify.main(args), 1)
self.assertEqual(verify.main(args + ['--overwrite']), 0)
self.assertEqual(verify.main(['--build-dir', str(root), '--receipt', str(root / 'SOUNDLAB.DSK'), '--overwrite']), 1)
self.assertTrue(verify.qualify(root)['passed'])
if __name__ == '__main__':
unittest.main()
+358
View File
@@ -0,0 +1,358 @@
# SPDX-License-Identifier: GPL-3.0-or-later
"""Authored, ROM-free fixtures for Sound Lab report evidence and DECB extraction."""
import hashlib
import importlib.util
import json
from pathlib import Path
import tempfile
import unittest
MODULE = Path(__file__).resolve().parents[1] / "host" / "soundlab_reports.py"
spec = importlib.util.spec_from_file_location("soundlab_reports", MODULE)
reports = importlib.util.module_from_spec(spec)
spec.loader.exec_module(reports)
def make_report(*, auto="OBSERVED", human="HEARD", ending=True, case="TON01-A", crc="7ABC", build="TEST-1", vector_set="1234", note=None):
lines = ["FORMAT=SOUNDLAB-1", f"RUN=0001 TARGET=REALCOCO BUILD_ID={build} VECTOR_SET_CRC16={vector_set}",
"MACHINE=COCO3 VIDEO=NTSC SPEED=NORMAL CART=26-3144A MOD=UNKNOWN",
f"CASE={case} VECTOR_CRC16={crc} AUTO={auto} HUMAN={human}",
"TX_COUNT=11 READY_TIMEOUTS=0 TICK_UNIT=VSYNC TICK_RATE_NUM=60000 TICK_RATE_DEN=1001",
"START_TICK=1234 END_TICK=1260 POLL_RESOLUTION_US=UNKNOWN", "STATUS_BEFORE=E0 STATUS_AFTER=E0"]
if note is not None:
lines.extend([f"NOTE_LENGTH={len(reports.decode_note(note))}", "NOTE=" + note])
lines.append(f"ENDCASE={case}")
if ending:
checksum = reports.crc16(('\r\n'.join(lines) + '\r\n').encode())
lines.append(f"ENDRUN=0001 COMPLETE=YES RECORD_COUNT={len(lines)} CHECKSUM_CRC16={checksum:04X}")
return ('\r\n'.join(lines) + '\r\n').encode()
def make_disk(files):
"""files is (name, data, explicit fragmented granule chain) tuples."""
disk = bytearray([0xFF] * reports.DISK_SIZE)
for index, (name, data, chain) in enumerate(files):
if not 0 < len(data) <= 2304 * len(chain) or len(data) <= 2304 * (len(chain) - 1):
raise ValueError("Fixture chain must exactly cover nonempty data")
base, ext = name.split(".")
entry = bytearray(32)
entry[:8] = base.encode().ljust(8, b' ')
entry[8:11] = ext.encode().ljust(3, b' ')
entry[11:14] = bytes([3, 0xFF, chain[0]])
entry[14:16] = (((len(data) - 1) % 256) + 1).to_bytes(2, 'big')
start = reports.DIRECTORY_OFFSET + index * 32
disk[start:start + 32] = entry
for position, granule in enumerate(chain):
last = position == len(chain) - 1
remaining = len(data) - position * 2304
disk[reports.FAT_OFFSET + granule] = 0xC0 + ((remaining + 255) // 256) if last else chain[position + 1]
chunk = data[position * 2304:(position + 1) * 2304]
offset = reports.granule_offset(granule)
disk[offset:offset + len(chunk)] = chunk
return disk
class DiskTests(unittest.TestCase):
def test_fragmented_chain_skips_directory_track_and_preserves_original(self):
content = b'A' * 2304 + b'B' * 2304 + b'END\r\n'
disk = make_disk([('snd0001.txt', content, [33, 34, 5])])
original = bytes(disk)
selected = reports.extract_reports(disk)
self.assertEqual(selected[0]['data'], content)
self.assertEqual(selected[0]['filename'], 'SND0001.TXT')
self.assertEqual(selected[0]['granules'], [33, 34, 5])
self.assertEqual(bytes(disk), original)
self.assertEqual(selected[0]['sha256'], hashlib.sha256(content).hexdigest())
self.assertEqual(reports.granule_offset(34), 18 * 18 * 256)
def test_full_sector_and_full_granule(self):
for size in (256, 2304, 2305):
with self.subTest(size=size):
data = bytes(i % 256 for i in range(size))
disk = make_disk([('SND0001.TXT', data, [0] if size <= 2304 else [0, 67])])
self.assertEqual(reports.extract_reports(disk)[0]['data'], data)
def test_only_report_names_extracted_and_binary_reports_rejected(self):
disk = make_disk([('NOTES.TXT', b'notes', [0]), ('SND0002.TXT', b'report', [1])])
self.assertEqual([item['filename'] for item in reports.extract_reports(disk)], ['SND0002.TXT'])
disk[reports.DIRECTORY_OFFSET + 32 + 12] = 0
with self.assertRaisesRegex(reports.SoundLabError, 'not marked.*ASCII'):
reports.extract_reports(disk)
def test_wrong_size_rejected_including_truncation(self):
for size in (0, reports.DISK_SIZE - 1, reports.DISK_SIZE + 1):
with self.subTest(size=size), self.assertRaises(reports.SoundLabError):
reports.extract_reports(bytes(size))
def test_invalid_fat_value(self):
disk = make_disk([('SND0001.TXT', b'hello', [0])])
disk[reports.FAT_OFFSET] = 0xCA
with self.assertRaisesRegex(reports.SoundLabError, 'Invalid FAT'):
reports.extract_reports(disk)
def test_fat_loop(self):
disk = make_disk([('SND0001.TXT', b'hello', [0])])
disk[reports.FAT_OFFSET] = 2
disk[reports.FAT_OFFSET + 2] = 0
with self.assertRaisesRegex(reports.SoundLabError, 'loop'):
reports.extract_reports(disk)
def test_free_granule_inside_chain(self):
disk = make_disk([('SND0001.TXT', b'hello', [0])])
disk[reports.FAT_OFFSET] = 0xFF
with self.assertRaisesRegex(reports.SoundLabError, 'free granule'):
reports.extract_reports(disk)
def test_crosslinks_with_unselected_file(self):
disk = make_disk([('SND0001.TXT', b'hello', [0]), ('OTHER.DAT', b'data', [1])])
disk[reports.DIRECTORY_OFFSET + 32 + 13] = 0
with self.assertRaisesRegex(reports.SoundLabError, 'Crosslinked'):
reports.extract_reports(disk)
def test_final_sector_count_and_empty_marker(self):
for byte_count in (257, 65535):
disk = make_disk([('SND0001.TXT', b'hello', [0])])
disk[reports.DIRECTORY_OFFSET + 14:reports.DIRECTORY_OFFSET + 16] = byte_count.to_bytes(2, 'big')
with self.subTest(byte_count=byte_count), self.assertRaisesRegex(reports.SoundLabError, 'byte count'):
reports.extract_reports(disk)
disk = make_disk([('SND0001.TXT', b'hello', [0])])
disk[reports.FAT_OFFSET] = 0xC0
with self.assertRaisesRegex(reports.SoundLabError, 'empty final granule'):
reports.extract_reports(disk)
def test_duplicate_names_and_unsafe_name(self):
disk = make_disk([('SND0001.TXT', b'a', [0]), ('snd0001.txt', b'b', [1])])
with self.assertRaisesRegex(reports.SoundLabError, 'Duplicate'):
reports.extract_reports(disk)
disk = make_disk([('SND0001.TXT', b'a', [0])])
disk[reports.DIRECTORY_OFFSET] = ord('/')
with self.assertRaisesRegex(reports.SoundLabError, 'Unsafe'):
reports.extract_reports(disk)
class ReportTests(unittest.TestCase):
def test_crc_known_vector(self):
self.assertEqual(reports.crc16(b'123456789'), 0x29B1)
def test_complete_report_and_escaped_note(self):
result = reports.parse_report(make_report(note=r'LINE\nTWO\\END\x21'))
self.assertTrue(result['complete'], result['issues'])
self.assertEqual(result['cases'][0]['notes'], ['LINE\nTWO\\END!'])
self.assertEqual(result['integrity'], {'record_count': 'VERIFIED', 'checksum_crc16': 'VERIFIED'})
self.assertEqual(result['cases'][0]['fields']['POLL_RESOLUTION_US'], 'UNKNOWN')
def test_lf_and_crlf_same_canonical_checksum(self):
self.assertTrue(reports.parse_report(make_report().replace(b'\r\n', b'\n'))['complete'])
def test_partial_run_keeps_case_evidence(self):
text = make_report(ending=False).rsplit(b'ENDCASE=', 1)[0]
result = reports.parse_report(text)
self.assertFalse(result['complete'])
self.assertFalse(result['cases'][0]['closed'])
self.assertEqual(result['cases'][0]['human'], 'HEARD')
self.assertTrue(any('partial' in issue for issue in result['issues']))
def test_bad_checksum_and_count(self):
data = make_report().replace(b'TX_COUNT=11', b'TX_COUNT=12').replace(b'RECORD_COUNT=8', b'RECORD_COUNT=7')
result = reports.parse_report(data)
self.assertFalse(result['valid'])
self.assertEqual(result['integrity']['checksum_crc16'], 'FAILED')
self.assertEqual(result['integrity']['record_count'], 'FAILED')
def test_optional_integrity_fields_are_honestly_unverified(self):
data = make_report().split(b' RECORD_COUNT=')[0] + b'\r\n'
result = reports.parse_report(data)
self.assertTrue(result['complete'])
self.assertEqual(result['integrity']['checksum_crc16'], 'NOT_PROVIDED')
def test_missing_human_never_infers_heard(self):
data = make_report().replace(b' HUMAN=HEARD', b'')
result = reports.parse_report(data)
self.assertEqual(result['cases'][0]['human'], 'UNKNOWN')
self.assertFalse(result['valid'])
def test_endcase_identity_and_trailing_records(self):
data = make_report().replace(b'ENDCASE=TON01-A', b'ENDCASE=OTHER') + b'CASE=LATE\r\n'
result = reports.parse_report(data)
self.assertFalse(result['valid'])
self.assertTrue(any('ENDCASE does not match' in value for value in result['issues']))
self.assertTrue(any('after ENDRUN' in value for value in result['issues']))
def test_notes_length_and_unknown_escape(self):
for bad in (b'NOTE_LENGTH=99\r\nNOTE=OK', b'NOTE_LENGTH=2\r\nNOTE=\\q'):
data = make_report(note='OK').replace(b'NOTE_LENGTH=2\r\nNOTE=OK', bad)
result = reports.parse_report(data)
self.assertFalse(result['valid'])
self.assertTrue(any('NOTE_LENGTH mismatch' in value or 'escape' in value for value in result['issues']))
def test_incomplete_note_and_run_identity(self):
data = make_report(ending=False).replace(b'ENDCASE=TON01-A\r\n', b'NOTE_LENGTH=3\r\n')
self.assertTrue(any('Truncated NOTE' in issue for issue in reports.parse_report(data)['issues']))
result = reports.parse_report(make_report().replace(b'ENDRUN=0001', b'ENDRUN=0002'))
self.assertTrue(any('does not match RUN' in issue for issue in result['issues']))
def test_invalid_ascii_and_format(self):
for data in (b'FORMAT=SOUNDLAB-2\n', b'FORMAT=SOUNDLAB-1\rRUN=1', b'FORMAT=SOUNDLAB-1\nNOTE=\xff', b'FORMAT=SOUNDLAB-1\n\x00'):
with self.subTest(data=data), self.assertRaises(reports.SoundLabError):
reports.parse_report(data)
def test_mixed_case_outcomes_compare_separately(self):
left = reports.parse_report(make_report(auto='observed', human='heard', case='ton01-a', crc='7abc'), 'left')
right = reports.parse_report(make_report(), 'right')
result = reports.compare_reports(left, right)
self.assertEqual(result['cases'][0]['comparison'], 'SAME')
other = reports.parse_report(make_report(human='NO_SOUND'), 'other')
result = reports.compare_reports(right, other)
self.assertEqual(result['cases'][0]['left_auto'], result['cases'][0]['right_auto'])
self.assertEqual(result['cases'][0]['comparison'], 'DIFFERENT')
def test_identity_mismatch_makes_not_comparable(self):
baseline = reports.parse_report(make_report())
for changed in (make_report(crc='ABCD'), make_report(build='OTHER'), make_report(vector_set='FFFF'), make_report(case='OTHER')):
result = reports.compare_reports(baseline, reports.parse_report(changed))
self.assertTrue(all(case['comparison'] == 'NOT_COMPARABLE' for case in result['cases']))
def test_authoritative_manifest_identity(self):
report = reports.parse_report(make_report())
manifest = {'build_id': 'TEST-1', 'vector_set_crc16': '1234', 'vectors': [{'case_id': 'TON01-A', 'crc16': '7ABC'}]}
self.assertEqual(reports.validate_manifest(report, manifest), [])
manifest['vectors'][0]['crc16'] = '1234'
compared = reports.compare_reports(report, report, manifest)
self.assertEqual(compared['cases'][0]['comparison'], 'NOT_COMPARABLE')
def test_repeated_attempts_preserved_and_compared_by_repeat(self):
base = make_report(ending=False).decode('ascii')
header, body = base.split('CASE=', 1)
case0 = 'CASE=' + body.replace('ENDCASE=', 'REPEAT=0\r\nENDCASE=')
case1 = case0.replace('REPEAT=0', 'REPEAT=1').replace('HUMAN=HEARD', 'HUMAN=UNSURE')
def finish(text):
raw = text.encode('ascii')
count = len(text.splitlines())
return raw + f'ENDRUN=0001 COMPLETE=YES RECORD_COUNT={count} CHECKSUM_CRC16={reports.crc16(raw):04X}\r\n'.encode('ascii')
left = reports.parse_report(finish(header + case0 + case1))
self.assertTrue(left['valid'], left['issues'])
self.assertEqual([case['repeat'] for case in left['cases']], [0, 1])
right = reports.parse_report(finish(header + case1 + case0))
self.assertTrue(right['valid'], right['issues'])
comparison = reports.compare_reports(left, right)
self.assertEqual([row['repeat'] for row in comparison['cases']], [0, 1])
self.assertEqual([row['comparison'] for row in comparison['cases']], ['SAME', 'SAME'])
changed = reports.parse_report(finish(header + case0 + case1.replace('HUMAN=UNSURE', 'HUMAN=NO_SOUND')))
comparison = reports.compare_reports(left, changed)
self.assertEqual([row['comparison'] for row in comparison['cases']], ['SAME', 'DIFFERENT'])
self.assertIn('case,repeat,auto,human', reports.render_csv(left))
self.assertIn('<th scope="col">repeat</th>', reports.render_html(left))
duplicate = reports.parse_report(finish(header + case0 + case0))
self.assertFalse(duplicate['valid'])
self.assertTrue(any('duplicate REPEAT=0' in issue for issue in duplicate['issues']))
def test_bad_repeat_and_missing_repeat_are_honest(self):
baseline = make_report(ending=False)
for value in ('-1', '65536', 'abc'):
invalid = baseline.replace(b'ENDCASE=', f'REPEAT={value}\r\nENDCASE='.encode()) + b'ENDRUN=0001 COMPLETE=YES\r\n'
parsed = reports.parse_report(invalid)
self.assertFalse(parsed['valid'])
self.assertIsNone(parsed['cases'][0]['repeat'])
self.assertEqual(reports.parse_report(make_report())['cases'][0]['repeat'], 0)
def test_raw_metric_differences_visible_even_with_same_outcomes(self):
a = make_report()
b = a.replace(b'TX_COUNT=11', b'TX_COUNT=12').split(b' RECORD_COUNT=')[0] + b'\r\n'
# Remove optional integrity from both: this fixture isolates metrics comparison.
a = a.split(b' RECORD_COUNT=')[0] + b'\r\n'
result = reports.compare_reports(reports.parse_report(a), reports.parse_report(b))
self.assertEqual(result['cases'][0]['comparison'], 'DIFFERENT')
self.assertEqual(result['cases'][0]['recorded_differences']['TX_COUNT'], {'left': '11', 'right': '12'})
def test_manifest_crc_aliases_and_invalid_schema(self):
report = reports.parse_report(make_report())
manifest = {'build_id': 'TEST-1', 'vector_set_crc16': 0x1234, 'vectors': {'TON01-A': '0x7abc'}}
self.assertEqual(reports.validate_manifest(report, manifest), [])
for bad in ([], {'vectors': 3}, {'vectors': ['not an object']}):
with self.subTest(manifest=bad), self.assertRaises(reports.SoundLabError):
reports.validate_manifest(report, bad)
def test_repeated_header_or_conflicting_controls(self):
for changed in (make_report().replace(b'ENDCASE=TON01-A', b'FORMAT=SOUNDLAB-1\r\nENDCASE=TON01-A'),
make_report().replace(b'CASE=TON01-A VECTOR', b'CASE=TON01-A RUN=0001 VECTOR')):
self.assertFalse(reports.parse_report(changed)['valid'])
def test_html_escapes_notes_and_csv_keeps_timing(self):
result = reports.parse_report(make_report(note='<script>alert(1)</script>'))
rendered = reports.render_html(result)
self.assertNotIn('<script>', rendered)
self.assertIn('&lt;script&gt;', rendered)
csv = reports.render_csv(result)
self.assertIn('TICK_RATE_DEN', csv)
self.assertIn('1001', csv)
class CliTests(unittest.TestCase):
def test_extract_convert_and_no_overwrites(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
disk = root / 'SOUNDLAB.DSK'
disk.write_bytes(make_disk([('SND0001.TXT', make_report(), [0])]))
output = root / 'reports'
self.assertEqual(reports.main(['extract', str(disk), '--output', str(output)]), 0)
self.assertEqual((output / 'SND0001.TXT').read_bytes(), make_report())
self.assertEqual(reports.main(['extract', str(disk), '--output', str(output)]), 1)
self.assertEqual(reports.main(['convert', str(output / 'SND0001.TXT'), '--output', str(root / 'converted')]), 0)
result = json.loads((root / 'converted' / 'SND0001.json').read_text())
self.assertTrue(result['complete'])
self.assertEqual(reports.main(['compare', str(output / 'SND0001.TXT'), str(output / 'SND0001.TXT'), '--output', str(root / 'comparison')]), 0)
def test_partial_conversion_returns_warning_with_evidence(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
report = root / 'partial.txt'
report.write_bytes(make_report(ending=False))
self.assertEqual(reports.main(['convert', str(report), '--output', str(root / 'result')]), 2)
self.assertTrue((root / 'result' / 'partial.html').is_file())
def test_inputs_cannot_be_overwritten_even_explicitly(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
# A source named *.json is still parsed as text, but conversion would target it.
report = root / 'report.json'
data = make_report()
report.write_bytes(data)
self.assertEqual(reports.main(['convert', str(report), '--output', str(root), '--overwrite']), 1)
self.assertEqual(report.read_bytes(), data)
def test_hardlinked_source_cannot_be_overwritten(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
report = root / 'report.txt'
report.write_bytes(make_report())
(root / 'report.json').hardlink_to(report)
self.assertEqual(reports.main(['convert', str(report), '--output', str(root), '--overwrite']), 1)
self.assertEqual(report.read_bytes(), make_report())
def test_explicit_overwrite_and_invalid_manifest(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
report = root / 'report.txt'
report.write_bytes(make_report())
output = root / 'output'
self.assertEqual(reports.main(['convert', str(report), '--output', str(output)]), 0)
self.assertEqual(reports.main(['convert', str(report), '--output', str(output), '--overwrite']), 0)
manifest = root / 'bad.json'
for invalid in ('[]', 'null'):
manifest.write_text(invalid)
self.assertEqual(reports.main(['convert', str(report), '--output', str(root / 'bad'), '--manifest', str(manifest)]), 1)
def test_preflight_rejects_all_outputs_before_writing(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
(root / 'exists').write_bytes(b'old')
with self.assertRaises(reports.SoundLabError):
reports.write_outputs({root / 'new': b'new', root / 'exists': b'replace'})
self.assertFalse((root / 'new').exists())
(root / 'link').symlink_to(root / 'exists')
with self.assertRaises(reports.SoundLabError):
reports.write_outputs({root / 'link': b'replace'}, overwrite=True)
if __name__ == '__main__':
unittest.main()
+69
View File
@@ -0,0 +1,69 @@
# SPDX-License-Identifier: GPL-3.0-or-later
"""Host tests for authored packet boundaries and deterministic vector identities."""
import importlib.util
import json
from pathlib import Path
import tempfile
import unittest
SPEC = importlib.util.spec_from_file_location('sound_vectors', Path(__file__).resolve().parents[1] / 'vectors' / 'generate.py')
V = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(V)
class VectorTests(unittest.TestCase):
def test_ccitt_false_check_value(self):
self.assertEqual(V.crc16(b'123456789'), 0x29B1)
def test_operand_ff_is_not_a_terminator(self):
self.assertEqual(len(V.sound_events([15, 0, 255, 255, 0, 0, 255, 0, 255])), 2)
V.validate_tx([0xAF, 0, 255, 11, 255, 255])
def test_malformed_packets_are_rejected(self):
invalid = ([0x98, 15, 0, 12, 255], # FF consumed as duration, no boundary terminator
[0x98, 15, 16, 12, 0, 255], # invalid tone high nibble
[0x98, 0x8F, 0x60, 1, 255], # reserved noise bits
[0xB0, 64, 0, 255], [0xB0, 5, 255], # invalid code / lacks final pause
[0xAF, 14, 0, 255], [0xAF, 1, 16, 255],
[0xAF, 0, 255], # FF is operand; missing terminator
[0x90, 65], [0x8F], [256], [])
for tx in invalid:
with self.subTest(tx=tx), self.assertRaises(ValueError):
V.validate_tx(list(tx))
def test_slots_allophones_and_shapes_are_complete(self):
cases = {v['id']: v for v in V.authored_vectors()}
for slot in range(8):
self.assertEqual(cases[f'BUF01-SP{slot}']['tx'][0], 0x90 + slot)
self.assertEqual(cases[f'BUF02-SN{slot}']['tx'][0], 0x98 + slot)
for code in range(64):
self.assertEqual(cases[f'ALP01-{code:02d}']['tx'], [0xB0, code, 0, 255, 0xF0])
for shape in range(16):
self.assertIn(0x60 + shape, cases[f'ENV01-{shape:02d}']['tx'])
def test_reproducible_manifest_and_header(self):
with tempfile.TemporaryDirectory() as temp:
one, two = Path(temp) / 'one', Path(temp) / 'two'
a, b = V.emit(one), V.emit(two)
self.assertEqual(a, b)
for name in ('vectors.h', 'vectors.json'):
self.assertEqual((one / name).read_bytes(), (two / name).read_bytes())
manifest = json.loads((one / 'vectors.json').read_text())
for case in manifest['vectors']:
self.assertEqual(case['crc16_ccitt_false'], f"{V.crc16(case['tx']):04X}")
self.assertEqual(case['tx_hex'], bytes(case['tx']).hex(' ').upper())
def test_version_one_packet_identities(self):
manifest = V.build_manifest()
self.assertEqual(manifest['vector_set_crc16'], '62E5')
cases = {v['case_id']: v['crc16'] for v in manifest['vectors']}
self.assertEqual({key: cases[key] for key in ('TXT01', 'REG01', 'FUN01-TUNE', 'ALP01-63', 'ENV01-10')},
{'TXT01': 'DEB7', 'REG01': 'E5E2', 'FUN01-TUNE': 'AF2A',
'ALP01-63': '2BD5', 'ENV01-10': 'BB15'})
for case in manifest['vectors']:
self.assertLessEqual(len(case['title']), 26)
self.assertLessEqual(len(case['prompt']), 62)
if __name__ == '__main__':
unittest.main()