407 lines
11 KiB
Python
407 lines
11 KiB
Python
|
#!/usr/bin/env python3
|
||
|
|
"""Tests for GlyphOS Cognitive Kernel
|
||
|
|
|
||
|
|
Tests verify:
|
||
|
|
- CognitiveKernel initialization and warmup
|
||
|
|
- GX execution through LAIN pipeline
|
||
|
|
- Result caching and accessors
|
||
|
|
- Glyph registry integration
|
||
|
|
- Functional API (singleton, run_gx, kernel_status)
|
||
|
|
"""
|
||
|
|
|
||
|
|
import sys
|
||
|
|
import tempfile
|
||
|
|
from pathlib import Path
|
||
|
|
|
||
|
|
sys.path.insert(0, str(Path.cwd()))
|
||
|
|
|
||
|
|
from glyphos.cognitive_kernel import (
|
||
|
|
CognitiveKernel,
|
||
|
|
get_kernel,
|
||
|
|
run_gx,
|
||
|
|
kernel_status,
|
||
|
|
)
|
||
|
|
from gx_cli.main import main as gx_main
|
||
|
|
from glyphs.super_registry import super_stats
|
||
|
|
|
||
|
|
|
||
|
|
def _create_test_gx() -> Path:
|
||
|
|
"""Create a test .gx file for kernel execution tests.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
Path to compiled .gx file
|
||
|
|
"""
|
||
|
|
# Use sample_code.py as source
|
||
|
|
source = Path("/home/dave/sample_code.py")
|
||
|
|
if not source.exists():
|
||
|
|
raise FileNotFoundError("Sample code not found")
|
||
|
|
|
||
|
|
# Compile to temporary .gx
|
||
|
|
temp_gx = Path(tempfile.gettempdir()) / "test_kernel.gx"
|
||
|
|
|
||
|
|
# Clean up old file
|
||
|
|
if temp_gx.exists():
|
||
|
|
temp_gx.unlink()
|
||
|
|
|
||
|
|
# Compile
|
||
|
|
exit_code = gx_main(["compile", str(source), "-o", str(temp_gx)])
|
||
|
|
if exit_code != 0:
|
||
|
|
raise RuntimeError(f"Compilation failed with exit code {exit_code}")
|
||
|
|
|
||
|
|
if not temp_gx.exists():
|
||
|
|
raise RuntimeError("Compilation did not produce output file")
|
||
|
|
|
||
|
|
return temp_gx
|
||
|
|
|
||
|
|
|
||
|
|
def test_kernel_initialization():
|
||
|
|
"""Test CognitiveKernel initialization."""
|
||
|
|
kernel = CognitiveKernel(auto_load_glyphs=True)
|
||
|
|
|
||
|
|
if kernel is None:
|
||
|
|
print("FAIL: Could not create CognitiveKernel")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if kernel._warmed_up:
|
||
|
|
print("FAIL: Kernel should not be warmed up on initialization")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if kernel._last_result is not None:
|
||
|
|
print("FAIL: Last result should be None initially")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print("PASS: CognitiveKernel initializes correctly")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def test_kernel_warmup():
|
||
|
|
"""Test kernel warmup and glyph loading."""
|
||
|
|
kernel = CognitiveKernel(auto_load_glyphs=True)
|
||
|
|
|
||
|
|
kernel.warmup()
|
||
|
|
|
||
|
|
if not kernel._warmed_up:
|
||
|
|
print("FAIL: Kernel not marked as warmed up")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if kernel._startup_time is None:
|
||
|
|
print("FAIL: Startup time not recorded")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if kernel._glyph_stats_cache is None:
|
||
|
|
print("FAIL: Glyph stats not cached")
|
||
|
|
return False
|
||
|
|
|
||
|
|
# Verify glyphs loaded
|
||
|
|
stats = kernel._glyph_stats_cache
|
||
|
|
if stats.get("total_glyphs") != 600:
|
||
|
|
print(f"FAIL: Expected 600 glyphs, got {stats.get('total_glyphs')}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if not stats.get("loaded"):
|
||
|
|
print("FAIL: Glyph registry not marked as loaded")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print(f"PASS: Kernel warmed up with {stats['total_glyphs']} glyphs")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def test_kernel_execute_gx():
|
||
|
|
"""Test kernel GX execution."""
|
||
|
|
kernel = CognitiveKernel(auto_load_glyphs=True)
|
||
|
|
kernel.warmup()
|
||
|
|
|
||
|
|
# Create test .gx file
|
||
|
|
try:
|
||
|
|
gx_path = _create_test_gx()
|
||
|
|
except Exception as e:
|
||
|
|
print(f"FAIL: Could not create test .gx: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
# Execute
|
||
|
|
try:
|
||
|
|
result = kernel.execute_gx(str(gx_path), mode="analyze")
|
||
|
|
except Exception as e:
|
||
|
|
print(f"FAIL: execute_gx raised exception: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
# Verify result structure
|
||
|
|
if result is None:
|
||
|
|
print("FAIL: execute_gx returned None")
|
||
|
|
return False
|
||
|
|
|
||
|
|
required_keys = ["fused_symbol", "diagnostics", "cognition_trace"]
|
||
|
|
for key in required_keys:
|
||
|
|
if key not in result:
|
||
|
|
print(f"FAIL: Missing key in result: {key}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
# Verify fused_symbol
|
||
|
|
fused = result.get("fused_symbol", {})
|
||
|
|
if not fused:
|
||
|
|
print("FAIL: fused_symbol is empty")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if "summary" not in fused:
|
||
|
|
print("FAIL: fused_symbol missing 'summary'")
|
||
|
|
return False
|
||
|
|
|
||
|
|
# Verify diagnostics
|
||
|
|
diags = result.get("diagnostics", {})
|
||
|
|
if not diags:
|
||
|
|
print("FAIL: diagnostics is empty")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print("PASS: kernel.execute_gx() returns valid ExecutionResult")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def test_kernel_result_accessors():
|
||
|
|
"""Test result accessor methods."""
|
||
|
|
kernel = CognitiveKernel(auto_load_glyphs=True)
|
||
|
|
kernel.warmup()
|
||
|
|
|
||
|
|
# Initially no result
|
||
|
|
if kernel.get_last_result() is not None:
|
||
|
|
print("FAIL: get_last_result should be None initially")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if kernel.get_last_trace() is not None:
|
||
|
|
print("FAIL: get_last_trace should be None initially")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if kernel.get_last_fused_symbol() is not None:
|
||
|
|
print("FAIL: get_last_fused_symbol should be None initially")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if kernel.get_last_resonance() is not None:
|
||
|
|
print("FAIL: get_last_resonance should be None initially")
|
||
|
|
return False
|
||
|
|
|
||
|
|
# Execute and verify accessors work
|
||
|
|
try:
|
||
|
|
gx_path = _create_test_gx()
|
||
|
|
except Exception as e:
|
||
|
|
print(f"FAIL: Could not create test .gx: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
kernel.execute_gx(str(gx_path))
|
||
|
|
|
||
|
|
# Now check accessors
|
||
|
|
last_result = kernel.get_last_result()
|
||
|
|
if last_result is None:
|
||
|
|
print("FAIL: get_last_result should not be None after execution")
|
||
|
|
return False
|
||
|
|
|
||
|
|
last_trace = kernel.get_last_trace()
|
||
|
|
if last_trace is None:
|
||
|
|
print("FAIL: get_last_trace should not be None after execution")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if not isinstance(last_trace, list):
|
||
|
|
print("FAIL: get_last_trace should return a list")
|
||
|
|
return False
|
||
|
|
|
||
|
|
last_symbol = kernel.get_last_fused_symbol()
|
||
|
|
if last_symbol is None:
|
||
|
|
print("FAIL: get_last_fused_symbol should not be None after execution")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if "summary" not in last_symbol:
|
||
|
|
print("FAIL: fused_symbol should have 'summary'")
|
||
|
|
return False
|
||
|
|
|
||
|
|
last_resonance = kernel.get_last_resonance()
|
||
|
|
if last_resonance is None:
|
||
|
|
print("FAIL: get_last_resonance should not be None after execution")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print("PASS: All result accessors work correctly")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def test_kernel_glyph_stats():
|
||
|
|
"""Test glyph statistics retrieval."""
|
||
|
|
kernel = CognitiveKernel(auto_load_glyphs=True)
|
||
|
|
kernel.warmup()
|
||
|
|
|
||
|
|
stats = kernel.get_glyph_stats()
|
||
|
|
|
||
|
|
if stats is None:
|
||
|
|
print("FAIL: get_glyph_stats returned None")
|
||
|
|
return False
|
||
|
|
|
||
|
|
required_keys = ["total_glyphs", "fields_present", "categories", "loaded"]
|
||
|
|
for key in required_keys:
|
||
|
|
if key not in stats:
|
||
|
|
print(f"FAIL: Missing key in glyph_stats: {key}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if stats["total_glyphs"] != 600:
|
||
|
|
print(f"FAIL: Expected 600 glyphs, got {stats['total_glyphs']}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if not isinstance(stats["categories"], list):
|
||
|
|
print("FAIL: categories should be a list")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if stats["loaded"] != True:
|
||
|
|
print("FAIL: Registry should be marked as loaded")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if "kernel_startup_time" not in stats:
|
||
|
|
print("FAIL: kernel_startup_time not in stats")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print(f"PASS: get_glyph_stats returns {stats['total_glyphs']} glyphs in {len(stats['categories'])} categories")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def test_get_kernel_singleton():
|
||
|
|
"""Test get_kernel() singleton behavior."""
|
||
|
|
kernel1 = get_kernel()
|
||
|
|
kernel2 = get_kernel()
|
||
|
|
|
||
|
|
if kernel1 is None or kernel2 is None:
|
||
|
|
print("FAIL: get_kernel returned None")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if kernel1 is not kernel2:
|
||
|
|
print("FAIL: get_kernel should return same instance")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if not kernel1._warmed_up:
|
||
|
|
print("FAIL: Kernel should be warmed up by get_kernel")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print("PASS: get_kernel returns warmed-up singleton")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def test_run_gx_function():
|
||
|
|
"""Test run_gx convenience function."""
|
||
|
|
try:
|
||
|
|
gx_path = _create_test_gx()
|
||
|
|
except Exception as e:
|
||
|
|
print(f"FAIL: Could not create test .gx: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
try:
|
||
|
|
result = run_gx(str(gx_path), mode="analyze")
|
||
|
|
except Exception as e:
|
||
|
|
print(f"FAIL: run_gx raised exception: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if result is None:
|
||
|
|
print("FAIL: run_gx returned None")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if "fused_symbol" not in result:
|
||
|
|
print("FAIL: Result missing fused_symbol")
|
||
|
|
return False
|
||
|
|
|
||
|
|
kernel = get_kernel()
|
||
|
|
last_result = kernel.get_last_result()
|
||
|
|
if last_result is not result:
|
||
|
|
print("FAIL: run_gx should update kernel's last_result")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print("PASS: run_gx convenience function works")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def test_kernel_status_function():
|
||
|
|
"""Test kernel_status() convenience function."""
|
||
|
|
# Reset singleton to test initial state
|
||
|
|
from glyphos import cognitive_kernel
|
||
|
|
cognitive_kernel._GLOBAL_KERNEL = None
|
||
|
|
|
||
|
|
status = kernel_status()
|
||
|
|
|
||
|
|
if status is None:
|
||
|
|
print("FAIL: kernel_status returned None")
|
||
|
|
return False
|
||
|
|
|
||
|
|
required_keys = [
|
||
|
|
"glyph_stats",
|
||
|
|
"last_run_present",
|
||
|
|
"last_mode",
|
||
|
|
"startup_time",
|
||
|
|
"is_warmed_up"
|
||
|
|
]
|
||
|
|
for key in required_keys:
|
||
|
|
if key not in status:
|
||
|
|
print(f"FAIL: Missing key in kernel_status: {key}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if not status["is_warmed_up"]:
|
||
|
|
print("FAIL: Kernel should be warmed up by kernel_status")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if status["last_run_present"]:
|
||
|
|
print("FAIL: Should not have last_run_present on fresh kernel")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if status["glyph_stats"]["total_glyphs"] != 600:
|
||
|
|
print("FAIL: glyph_stats should have 600 glyphs")
|
||
|
|
return False
|
||
|
|
|
||
|
|
# Execute and verify status updates
|
||
|
|
try:
|
||
|
|
gx_path = _create_test_gx()
|
||
|
|
run_gx(str(gx_path))
|
||
|
|
except Exception as e:
|
||
|
|
print(f"FAIL: Could not execute test: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
status = kernel_status()
|
||
|
|
if not status["last_run_present"]:
|
||
|
|
print("FAIL: Should have last_run_present after execution")
|
||
|
|
return False
|
||
|
|
|
||
|
|
if status["last_mode"] != "analyze":
|
||
|
|
print("FAIL: last_mode should be 'analyze'")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print("PASS: kernel_status correctly reflects kernel state")
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def main_test():
|
||
|
|
print("[TEST SUITE] test_cognitive_kernel.py")
|
||
|
|
print()
|
||
|
|
|
||
|
|
tests = [
|
||
|
|
("Kernel initialization", test_kernel_initialization),
|
||
|
|
("Kernel warmup", test_kernel_warmup),
|
||
|
|
("Execute GX", test_kernel_execute_gx),
|
||
|
|
("Result accessors", test_kernel_result_accessors),
|
||
|
|
("Glyph stats", test_kernel_glyph_stats),
|
||
|
|
("get_kernel singleton", test_get_kernel_singleton),
|
||
|
|
("run_gx function", test_run_gx_function),
|
||
|
|
("kernel_status function", test_kernel_status_function),
|
||
|
|
]
|
||
|
|
|
||
|
|
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")
|
||
|
|
|
||
|
|
return 0 if failed == 0 else 1
|
||
|
|
|
||
|
|
|
||
|
|
if __name__ == "__main__":
|
||
|
|
sys.exit(main_test())
|