GlyphRunner System
134 lines
4.0 KiB
Python
Executable File
134 lines
4.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import sys
|
|
from pathlib import Path
|
|
import json
|
|
|
|
sys.path.insert(0, str(Path.cwd()))
|
|
|
|
from gx_cli.main import main
|
|
from runtime_executor.gx_loader import load_gx
|
|
|
|
|
|
def test_deterministic_structure():
|
|
"""Test that compiled .gx files have the same structure"""
|
|
outputs = [Path(f"/tmp/test_struct_{i}.gx") for i in range(3)]
|
|
|
|
for output in outputs:
|
|
if output.exists():
|
|
output.unlink()
|
|
main(["compile", "/home/dave/sample_code.py", "-o", str(output)])
|
|
|
|
# Load all files and check structure
|
|
results = []
|
|
for output in outputs:
|
|
manifest, payload = load_gx(str(output))
|
|
results.append({
|
|
"manifest_keys": sorted(manifest.keys()),
|
|
"payload_size": len(payload),
|
|
"file_size": output.stat().st_size,
|
|
"segments": len(manifest.get("codex_lineage", {}).get("segments", []))
|
|
})
|
|
|
|
# Check structure consistency (ignore timestamps)
|
|
if not all(r["manifest_keys"] == results[0]["manifest_keys"] for r in results):
|
|
print("FAIL: manifest keys differ")
|
|
return False
|
|
|
|
if not all(r["payload_size"] == results[0]["payload_size"] for r in results):
|
|
print("FAIL: payload sizes differ")
|
|
return False
|
|
|
|
if not all(r["segments"] == results[0]["segments"] for r in results):
|
|
print("FAIL: segment counts differ")
|
|
return False
|
|
|
|
print(f"PASS: .gx structure is deterministic (payload={results[0]['payload_size']} bytes, {results[0]['segments']} segments)")
|
|
return True
|
|
|
|
|
|
def test_deterministic_magic_and_size():
|
|
"""Test that magic bytes and file sizes are deterministic"""
|
|
outputs = [Path(f"/tmp/test_magic_{i}.gx") for i in range(3)]
|
|
|
|
sizes = []
|
|
for output in outputs:
|
|
if output.exists():
|
|
output.unlink()
|
|
main(["compile", "/home/dave/sample_code.py", "-o", str(output)])
|
|
sizes.append(output.stat().st_size)
|
|
|
|
# All sizes should match
|
|
if not all(s == sizes[0] for s in sizes):
|
|
print(f"FAIL: sizes vary: {sizes}")
|
|
return False
|
|
|
|
# Check magic bytes
|
|
for output in outputs:
|
|
data = output.read_bytes()
|
|
if not data.startswith(b'XIC'):
|
|
print("FAIL: invalid magic bytes")
|
|
return False
|
|
|
|
print(f"PASS: Magic bytes and file sizes are deterministic ({sizes[0]} bytes)")
|
|
return True
|
|
|
|
|
|
def test_payload_determinism():
|
|
"""Test that compressed payloads are deterministic"""
|
|
outputs = [Path(f"/tmp/test_payload_{i}.gx") for i in range(2)]
|
|
|
|
for output in outputs:
|
|
if output.exists():
|
|
output.unlink()
|
|
main(["compile", "/home/dave/sample_code.py", "-o", str(output)])
|
|
|
|
# Extract payloads
|
|
_, payload1 = load_gx(str(outputs[0]))
|
|
_, payload2 = load_gx(str(outputs[1]))
|
|
|
|
if payload1 != payload2:
|
|
print("FAIL: compressed payloads differ")
|
|
return False
|
|
|
|
print(f"PASS: Compressed payload is deterministic ({len(payload1)} bytes)")
|
|
return True
|
|
|
|
|
|
def main_test():
|
|
print("[TEST SUITE] test_determinism.py")
|
|
print()
|
|
|
|
tests = [
|
|
("Deterministic structure", test_deterministic_structure),
|
|
("Deterministic magic/size", test_deterministic_magic_and_size),
|
|
("Payload determinism", test_payload_determinism),
|
|
]
|
|
|
|
passed = 0
|
|
failed = 0
|
|
|
|
for name, test_func in tests:
|
|
print(f"Running: {name}...", end=" ")
|
|
try:
|
|
if test_func():
|
|
passed += 1
|
|
else:
|
|
failed += 1
|
|
except Exception as e:
|
|
print(f"FAIL: {e}")
|
|
failed += 1
|
|
|
|
print()
|
|
print(f"Results: {passed} passed, {failed} failed")
|
|
print()
|
|
print("Note: Full byte-for-byte determinism is not expected due to")
|
|
print(" timestamp fields in the manifest. This test verifies")
|
|
print(" that structure, size, magic bytes, and payload are")
|
|
print(" deterministic, which is sufficient for the pipeline.")
|
|
|
|
return 0 if failed == 0 else 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main_test())
|