john/McRogueFace
1
0
Fork 0
Code Issues 32 Pull requests Projects Releases Wiki Activity

Refactor timing tests to use mcrfpy.step() for synchronous execution

Browse source 
Converts tests from Timer-based async patterns to step()-based sync
patterns, eliminating timeout issues in headless testing.

Refactored tests:
- simple_timer_screenshot_test.py
- test_animation_callback_simple.py
- test_animation_property_locking.py
- test_animation_raii.py
- test_animation_removal.py
- test_timer_callback.py

Also updates KNOWN_ISSUES.md with comprehensive documentation on
the step()-based testing pattern including examples and best practices.

🤖 Generated with Claude Code (https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Frick 2026-01-14 02:56:21 +00:00
commit 4528ece0a7
7 changed files with 325 additions and 290 deletions
Download patch file Download diff file Expand all files Collapse all files

88
tests/KNOWN_ISSUES.md
View file

@ -8,20 +8,94 @@ As of 2026-01-14, with `--mcrf-timeout=5`:
- 40 timeout failures (tests requiring timers/animations) - 40 timeout failures (tests requiring timers/animations)
- 19 actual failures (API changes, missing features, or bugs) - 19 actual failures (API changes, missing features, or bugs)
## Timeout Failures (40 tests) ## Synchronous Testing with `mcrfpy.step()`
These tests require timers, animations, or callbacks that don't complete within the 5s timeout. **RECOMMENDED:** Use `mcrfpy.step(t)` to advance simulation time synchronously instead of relying on Timer callbacks and the game loop. This eliminates timeout issues and makes tests deterministic.
Run with `--mcrf-timeout=30` for a more permissive test run.
**Animation/Timer tests:** ### Old Pattern (Timer-based, async)
- WORKING_automation_test_example.py
- benchmark_logging_test.py ```python
- keypress_scene_validation_test.py # OLD: Requires game loop, subject to timeouts
def run_tests(timer, runtime):
# tests here
sys.exit(0)
mcrfpy.Timer("run", run_tests, 100, once=True)
# Script ends, game loop runs, timer eventually fires
```
### New Pattern (step-based, sync)
```python
# NEW: Synchronous, no timeouts
import mcrfpy
import sys
# Setup scene
scene = mcrfpy.Scene("test")
scene.activate()
mcrfpy.step(0.1) # Initialize scene
# Run tests directly
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
scene.children.append(frame)
# Start animation
anim = mcrfpy.Animation("x", 500.0, 1.0, "linear")
anim.start(frame)
# Advance simulation to complete animation
mcrfpy.step(1.5) # Advances 1.5 seconds synchronously
# Verify results
if frame.x == 500.0:
print("PASS")
sys.exit(0)
else:
print("FAIL")
sys.exit(1)
```
### Key Differences
| Aspect | Timer-based | step()-based |
|--------|-------------|--------------|
| Execution | Async (game loop) | Sync (immediate) |
| Timeout risk | High | None |
| Determinism | Variable | Consistent |
| Timer firing | Once per step() call | Per elapsed interval |
### Timer Behavior with `step()`
- Timers fire once per `step()` call if their interval has elapsed
- To fire a timer multiple times, call `step()` multiple times:
```python
# Timer fires every 100ms
timer = mcrfpy.Timer("tick", callback, 100)
# This fires the timer ~6 times
for i in range(6):
mcrfpy.step(0.1) # Each step processes timers once
```
## Refactored Tests
The following tests have been converted to use `mcrfpy.step()`:
- simple_timer_screenshot_test.py - simple_timer_screenshot_test.py
- test_animation_callback_simple.py - test_animation_callback_simple.py
- test_animation_property_locking.py - test_animation_property_locking.py
- test_animation_raii.py - test_animation_raii.py
- test_animation_removal.py - test_animation_removal.py
- test_timer_callback.py
- test_timer_once.py
## Remaining Timeout Failures
These tests still use Timer-based async patterns:
- WORKING_automation_test_example.py
- benchmark_logging_test.py
- keypress_scene_validation_test.py
- test_empty_animation_manager.py - test_empty_animation_manager.py
- test_simple_callback.py - test_simple_callback.py

30
tests/unit/simple_timer_screenshot_test.py
View file

@ -1,28 +1,23 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""Simplified test to verify timer-based screenshots work""" """Test to verify timer-based screenshots work using mcrfpy.step() for synchronous execution"""
import mcrfpy import mcrfpy
from mcrfpy import automation from mcrfpy import automation
import sys
# Counter to track timer calls # Counter to track timer calls
call_count = 0 call_count = 0
def take_screenshot_and_exit(timer, runtime): def take_screenshot(timer, runtime):
"""Timer callback that takes screenshot then exits""" """Timer callback that takes screenshot"""
global call_count global call_count
call_count += 1 call_count += 1
print(f"Timer callback fired! (call #{call_count}, runtime={runtime})")
print(f"\nTimer callback fired! (call #{call_count})")
# Take screenshot # Take screenshot
filename = f"timer_screenshot_test_{call_count}.png" filename = f"timer_screenshot_test_{call_count}.png"
result = automation.screenshot(filename) result = automation.screenshot(filename)
print(f"Screenshot result: {result} -> {filename}") print(f"Screenshot result: {result} -> {filename}")
# Exit after first call
if call_count >= 1:
print("Exiting game...")
mcrfpy.exit()
# Set up a simple scene # Set up a simple scene
print("Creating test scene...") print("Creating test scene...")
test = mcrfpy.Scene("test") test = mcrfpy.Scene("test")
@ -35,6 +30,17 @@ frame = mcrfpy.Frame(pos=(100, 100), size=(200, 200),
ui.append(frame) ui.append(frame)
print("Setting timer to fire in 100ms...") print("Setting timer to fire in 100ms...")
mcrfpy.Timer("screenshot_timer", take_screenshot_and_exit, 100, once=True) timer = mcrfpy.Timer("screenshot_timer", take_screenshot, 100, once=True)
print(f"Timer created: {timer}")
print("Setup complete. Game loop starting...") # Use mcrfpy.step() to advance simulation synchronously instead of waiting
print("Advancing simulation by 200ms using step()...")
mcrfpy.step(0.2) # Advance 200ms - timer at 100ms should fire
# Verify timer fired
if call_count >= 1:
print("SUCCESS: Timer fired and screenshot taken!")
sys.exit(0)
else:
print(f"FAIL: Expected call_count >= 1, got {call_count}")
sys.exit(1)

84
tests/unit/test_animation_callback_simple.py
View file

@ -1,73 +1,55 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""Simple test for animation callbacks - demonstrates basic usage""" """Simple test for animation callbacks using mcrfpy.step() for synchronous execution"""
import mcrfpy import mcrfpy
import sys import sys
print("Animation Callback Demo")
print("=" * 30)
# Global state to track callback # Global state to track callback
callback_count = 0 callback_count = 0
callback_demo = None # Will be set in setup_and_run
def my_callback(anim, target): def my_callback(anim, target):
"""Simple callback that prints when animation completes""" """Simple callback that prints when animation completes"""
global callback_count global callback_count
callback_count += 1 callback_count += 1
print(f"Animation completed! Callback #{callback_count}") print(f"Animation completed! Callback #{callback_count}")
# For now, anim and target are None - future enhancement
def setup_and_run(): # Create scene
"""Set up scene and run animation with callback""" callback_demo = mcrfpy.Scene("callback_demo")
global callback_demo callback_demo.activate()
# Create scene
callback_demo = mcrfpy.Scene("callback_demo")
callback_demo.activate()
# Create a frame to animate # Create a frame to animate
frame = mcrfpy.Frame((100, 100), (200, 200), fill_color=(255, 0, 0)) frame = mcrfpy.Frame((100, 100), (200, 200), fill_color=(255, 0, 0))
ui = callback_demo.children ui = callback_demo.children
ui.append(frame) ui.append(frame)
# Create animation with callback # Test 1: Animation with callback
print("Starting animation with callback...") print("Starting animation with callback (1.0s duration)...")
anim = mcrfpy.Animation("x", 400.0, 1.0, "easeInOutQuad", callback=my_callback) anim = mcrfpy.Animation("x", 400.0, 1.0, "easeInOutQuad", callback=my_callback)
anim.start(frame) anim.start(frame)
# Schedule check after animation should complete # Use mcrfpy.step() to advance past animation completion
mcrfpy.Timer("check", check_result, 1500, once=True) mcrfpy.step(1.5) # Advance 1.5 seconds - animation completes at 1.0s
def check_result(timer, runtime): if callback_count != 1:
"""Check if callback fired correctly""" print(f"FAIL: Expected 1 callback, got {callback_count}")
global callback_count, callback_demo sys.exit(1)
print("SUCCESS: Callback fired exactly once!")
if callback_count == 1: # Test 2: Animation without callback
print("SUCCESS: Callback fired exactly once!") print("\nTesting animation without callback (0.5s duration)...")
anim2 = mcrfpy.Animation("y", 300.0, 0.5, "linear")
anim2.start(frame)
# Test 2: Animation without callback # Advance past second animation
print("\nTesting animation without callback...") mcrfpy.step(0.7)
ui = callback_demo.children
frame = ui[0]
anim2 = mcrfpy.Animation("y", 300.0, 0.5, "linear") if callback_count != 1:
anim2.start(frame) print(f"FAIL: Callback count changed to {callback_count}")
sys.exit(1)
mcrfpy.Timer("final", final_check, 700, once=True) print("SUCCESS: No unexpected callbacks fired!")
else: print("\nAnimation callback feature working correctly!")
print(f"FAIL: Expected 1 callback, got {callback_count}") sys.exit(0)
sys.exit(1)
def final_check(timer, runtime):
"""Final check - callback count should still be 1"""
global callback_count
if callback_count == 1:
print("SUCCESS: No unexpected callbacks fired!")
print("\nAnimation callback feature working correctly!")
sys.exit(0)
else:
print(f"FAIL: Callback count changed to {callback_count}")
sys.exit(1)
# Start the demo
print("Animation Callback Demo")
print("=" * 30)
setup_and_run()

9
tests/unit/test_animation_property_locking.py
View file

@ -210,7 +210,7 @@ def test_8_replace_completes_old():
test_result("Replace completes old animation", False, str(e)) test_result("Replace completes old animation", False, str(e))
def run_all_tests(timer, runtime): def run_all_tests():
"""Run all property locking tests""" """Run all property locking tests"""
print("\nRunning Animation Property Locking Tests...") print("\nRunning Animation Property Locking Tests...")
print("-" * 50) print("-" * 50)
@ -245,5 +245,8 @@ def run_all_tests(timer, runtime):
test = mcrfpy.Scene("test") test = mcrfpy.Scene("test")
test.activate() test.activate()
# Start tests after a brief delay to allow scene to initialize # Use mcrfpy.step() to advance simulation for scene initialization
mcrfpy.Timer("start", run_all_tests, 100, once=True) mcrfpy.step(0.1) # Brief step to initialize scene
# Run tests directly (no timer needed with step-based approach)
run_all_tests()

306
tests/unit/test_animation_raii.py
View file

@ -2,6 +2,7 @@
""" """
Test the RAII AnimationManager implementation. Test the RAII AnimationManager implementation.
This verifies that weak_ptr properly handles all crash scenarios. This verifies that weak_ptr properly handles all crash scenarios.
Uses mcrfpy.step() for synchronous test execution.
""" """
import mcrfpy import mcrfpy
@ -19,189 +20,14 @@ def test_result(name, passed, details=""):
global tests_passed, tests_failed global tests_passed, tests_failed
if passed: if passed:
tests_passed += 1 tests_passed += 1
result = f"✓ {name}" result = f"PASS: {name}"
else: else:
tests_failed += 1 tests_failed += 1
result = f"✗ {name}: {details}" result = f"FAIL: {name}: {details}"
print(result) print(result)
test_results.append((name, passed, details)) test_results.append((name, passed, details))
def test_1_basic_animation(): # Setup scene
"""Test that basic animations still work"""
try:
ui = test.children
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
ui.append(frame)
anim = mcrfpy.Animation("x", 200.0, 1000, "linear")
anim.start(frame)
# Check if animation has valid target
if hasattr(anim, 'hasValidTarget'):
valid = anim.hasValidTarget()
test_result("Basic animation with hasValidTarget", valid)
else:
test_result("Basic animation", True)
except Exception as e:
test_result("Basic animation", False, str(e))
def test_2_remove_animated_object():
"""Test removing object with active animation"""
try:
ui = test.children
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
ui.append(frame)
# Start animation
anim = mcrfpy.Animation("x", 500.0, 2000, "easeInOut")
anim.start(frame)
# Remove the frame
ui.remove(0)
# Check if animation knows target is gone
if hasattr(anim, 'hasValidTarget'):
valid = anim.hasValidTarget()
test_result("Animation detects removed target", not valid)
else:
# If method doesn't exist, just check we didn't crash
test_result("Remove animated object", True)
except Exception as e:
test_result("Remove animated object", False, str(e))
def test_3_complete_animation():
"""Test completing animation immediately"""
try:
ui = test.children
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
ui.append(frame)
# Start animation
anim = mcrfpy.Animation("x", 500.0, 2000, "linear")
anim.start(frame)
# Complete it
if hasattr(anim, 'complete'):
anim.complete()
# Frame should now be at x=500
test_result("Animation complete method", True)
else:
test_result("Animation complete method", True, "Method not available")
except Exception as e:
test_result("Animation complete method", False, str(e))
def test_4_multiple_animations_timer():
"""Test creating multiple animations in timer callback"""
success = False
def create_animations(timer, runtime):
nonlocal success
try:
ui = test.children
frame = mcrfpy.Frame(pos=(200, 200), size=(100, 100))
ui.append(frame)
# Create multiple animations rapidly (this used to crash)
for i in range(10):
anim = mcrfpy.Animation("x", 300.0 + i * 10, 1000, "linear")
anim.start(frame)
success = True
except Exception as e:
print(f"Timer animation error: {e}")
finally:
mcrfpy.Timer("exit", lambda t, r: None, 100, once=True)
# Clear scene
ui = test.children
while len(ui) > 0:
ui.remove(len(ui) - 1)
mcrfpy.Timer("test", create_animations, 50, once=True)
mcrfpy.Timer("check", lambda t, r: test_result("Multiple animations in timer", success), 200, once=True)
def test_5_scene_cleanup():
"""Test that changing scenes cleans up animations"""
try:
# Create a second scene
test2 = mcrfpy.Scene("test2")
# Add animated objects to first scene
ui = test.children
for i in range(5):
frame = mcrfpy.Frame(pos=(50 * i, 100), size=(40, 40))
ui.append(frame)
anim = mcrfpy.Animation("y", 300.0, 2000, "easeOutBounce")
anim.start(frame)
# Switch scenes (animations should become invalid)
test2.activate()
# Switch back
test.activate()
test_result("Scene change cleanup", True)
except Exception as e:
test_result("Scene change cleanup", False, str(e))
def test_6_animation_after_clear():
"""Test animations after clearing UI"""
try:
ui = test.children
# Create and animate
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
ui.append(frame)
anim = mcrfpy.Animation("w", 200.0, 1500, "easeInOutCubic")
anim.start(frame)
# Clear all UI
while len(ui) > 0:
ui.remove(len(ui) - 1)
# Animation should handle this gracefully
if hasattr(anim, 'hasValidTarget'):
valid = anim.hasValidTarget()
test_result("Animation after UI clear", not valid)
else:
test_result("Animation after UI clear", True)
except Exception as e:
test_result("Animation after UI clear", False, str(e))
def run_all_tests(timer, runtime):
"""Run all RAII tests"""
print("\nRunning RAII Animation Tests...")
print("-" * 40)
test_1_basic_animation()
test_2_remove_animated_object()
test_3_complete_animation()
test_4_multiple_animations_timer()
test_5_scene_cleanup()
test_6_animation_after_clear()
# Schedule result summary
mcrfpy.Timer("results", print_results, 500, once=True)
def print_results(timer, runtime):
"""Print test results"""
print("\n" + "=" * 40)
print(f"Tests passed: {tests_passed}")
print(f"Tests failed: {tests_failed}")
if tests_failed == 0:
print("\n+ All tests passed! RAII implementation is working correctly.")
else:
print(f"\nx {tests_failed} tests failed.")
print("\nFailed tests:")
for name, passed, details in test_results:
if not passed:
print(f" - {name}: {details}")
# Exit
mcrfpy.Timer("exit", lambda t, r: sys.exit(0 if tests_failed == 0 else 1), 500, once=True)
# Setup and run
test = mcrfpy.Scene("test") test = mcrfpy.Scene("test")
test.activate() test.activate()
@ -211,5 +37,125 @@ bg = mcrfpy.Frame(pos=(0, 0), size=(1024, 768))
bg.fill_color = mcrfpy.Color(20, 20, 30) bg.fill_color = mcrfpy.Color(20, 20, 30)
ui.append(bg) ui.append(bg)
# Start tests # Initialize scene
start_timer = mcrfpy.Timer("start", run_all_tests, 100, once=True) mcrfpy.step(0.1)
print("\nRunning RAII Animation Tests...")
print("-" * 40)
# Test 1: Basic animation
try:
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
ui.append(frame)
anim = mcrfpy.Animation("x", 200.0, 1000, "linear")
anim.start(frame)
if hasattr(anim, 'hasValidTarget'):
valid = anim.hasValidTarget()
test_result("Basic animation with hasValidTarget", valid)
else:
test_result("Basic animation", True)
except Exception as e:
test_result("Basic animation", False, str(e))
# Test 2: Remove animated object
try:
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
ui.append(frame)
anim = mcrfpy.Animation("x", 500.0, 2000, "easeInOut")
anim.start(frame)
ui.remove(frame)
if hasattr(anim, 'hasValidTarget'):
valid = anim.hasValidTarget()
test_result("Animation detects removed target", not valid)
else:
test_result("Remove animated object", True)
except Exception as e:
test_result("Remove animated object", False, str(e))
# Test 3: Complete animation immediately
try:
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
ui.append(frame)
anim = mcrfpy.Animation("x", 500.0, 2000, "linear")
anim.start(frame)
if hasattr(anim, 'complete'):
anim.complete()
test_result("Animation complete method", True)
else:
test_result("Animation complete method", True, "Method not available")
except Exception as e:
test_result("Animation complete method", False, str(e))
# Test 4: Multiple animations rapidly
try:
frame = mcrfpy.Frame(pos=(200, 200), size=(100, 100))
ui.append(frame)
for i in range(10):
anim = mcrfpy.Animation("x", 300.0 + i * 10, 1000, "linear")
anim.start(frame)
test_result("Multiple animations rapidly", True)
except Exception as e:
test_result("Multiple animations rapidly", False, str(e))
# Test 5: Scene cleanup
try:
test2 = mcrfpy.Scene("test2")
for i in range(5):
frame = mcrfpy.Frame(pos=(50 * i, 100), size=(40, 40))
ui.append(frame)
anim = mcrfpy.Animation("y", 300.0, 2000, "easeOutBounce")
anim.start(frame)
test2.activate()
mcrfpy.step(0.1)
test.activate()
mcrfpy.step(0.1)
test_result("Scene change cleanup", True)
except Exception as e:
test_result("Scene change cleanup", False, str(e))
# Test 6: Animation after clearing UI
try:
frame = mcrfpy.Frame(pos=(100, 100), size=(100, 100))
ui.append(frame)
anim = mcrfpy.Animation("w", 200.0, 1500, "easeInOutCubic")
anim.start(frame)
# Clear all UI except background - iterate in reverse
for i in range(len(ui) - 1, 0, -1):
ui.remove(ui[i])
if hasattr(anim, 'hasValidTarget'):
valid = anim.hasValidTarget()
test_result("Animation after UI clear", not valid)
else:
test_result("Animation after UI clear", True)
except Exception as e:
test_result("Animation after UI clear", False, str(e))
# Print results
print("\n" + "=" * 40)
print(f"Tests passed: {tests_passed}")
print(f"Tests failed: {tests_failed}")
if tests_failed == 0:
print("\nAll tests passed! RAII implementation is working correctly.")
else:
print(f"\n{tests_failed} tests failed.")
print("\nFailed tests:")
for name, passed, details in test_results:
if not passed:
print(f" - {name}: {details}")
sys.exit(0 if tests_failed == 0 else 1)

83
tests/unit/test_animation_removal.py
View file

@ -1,40 +1,14 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
""" """
Test if the crash is related to removing animated objects Test if the crash is related to removing animated objects.
Uses mcrfpy.step() for synchronous test execution.
""" """
import mcrfpy import mcrfpy
import sys import sys
def clear_and_recreate(timer, runtime): print("Animation Removal Test")
"""Clear UI and recreate - mimics demo switching""" print("=" * 40)
print(f"\nTimer called at {runtime}")
ui = test.children
# Remove all but first 2 items (like clear_demo_objects)
print(f"Scene has {len(ui)} elements before clearing")
while len(ui) > 2:
ui.remove(len(ui)-1)
print(f"Scene has {len(ui)} elements after clearing")
# Create new animated objects
print("Creating new animated objects...")
for i in range(5):
f = mcrfpy.Frame(100 + i*50, 200, 40, 40)
f.fill_color = mcrfpy.Color(100 + i*30, 50, 200)
ui.append(f)
# Start animation on the new frame
target_x = 300 + i * 50
anim = mcrfpy.Animation("x", float(target_x), 1.0, "easeInOut")
anim.start(f)
print("New objects created and animated")
# Schedule exit
global exit_timer
exit_timer = mcrfpy.Timer("exit", lambda t, r: sys.exit(0), 2000, once=True)
# Create initial scene # Create initial scene
print("Creating scene...") print("Creating scene...")
@ -47,20 +21,61 @@ title = mcrfpy.Caption(pos=(400, 20), text="Test Title")
subtitle = mcrfpy.Caption(pos=(400, 50), text="Test Subtitle") subtitle = mcrfpy.Caption(pos=(400, 50), text="Test Subtitle")
ui.extend([title, subtitle]) ui.extend([title, subtitle])
# Initialize scene
mcrfpy.step(0.1)
# Create initial animated objects # Create initial animated objects
print("Creating initial animated objects...") print("Creating initial animated objects...")
initial_frames = []
for i in range(10): for i in range(10):
f = mcrfpy.Frame(pos=(50 + i*30, 100), size=(25, 25)) f = mcrfpy.Frame(pos=(50 + i*30, 100), size=(25, 25))
f.fill_color = mcrfpy.Color(255, 100, 100) f.fill_color = mcrfpy.Color(255, 100, 100)
ui.append(f) ui.append(f)
initial_frames.append(f)
# Animate them # Animate them
anim = mcrfpy.Animation("y", 300.0, 2.0, "easeOutBounce") anim = mcrfpy.Animation("y", 300.0, 2.0, "easeOutBounce")
anim.start(f) anim.start(f)
print(f"Initial scene has {len(ui)} elements") print(f"Initial scene has {len(ui)} elements")
# Schedule the clear and recreate # Let animations run a bit
switch_timer = mcrfpy.Timer("switch", clear_and_recreate, 1000, once=True) mcrfpy.step(0.5)
print("\nEntering game loop...") # Clear and recreate - mimics demo switching
print("\nClearing and recreating...")
print(f"Scene has {len(ui)} elements before clearing")
# Remove all but first 2 items (like clear_demo_objects)
# Use reverse iteration to remove by element
while len(ui) > 2:
ui.remove(ui[-1])
print(f"Scene has {len(ui)} elements after clearing")
# Create new animated objects
print("Creating new animated objects...")
for i in range(5):
f = mcrfpy.Frame(pos=(100 + i*50, 200), size=(40, 40))
f.fill_color = mcrfpy.Color(100 + i*30, 50, 200)
ui.append(f)
# Start animation on the new frame
target_x = 300 + i * 50
anim = mcrfpy.Animation("x", float(target_x), 1.0, "easeInOut")
anim.start(f)
print("New objects created and animated")
print(f"Scene now has {len(ui)} elements")
# Let new animations run
mcrfpy.step(1.5)
# Final check
print(f"\nFinal scene has {len(ui)} elements")
if len(ui) == 7: # 2 captions + 5 new frames
print("SUCCESS: Animation removal test passed!")
sys.exit(0)
else:
print(f"FAIL: Expected 7 elements, got {len(ui)}")
sys.exit(1)

15
tests/unit/test_timer_callback.py
View file

@ -1,6 +1,7 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
""" """
Test timer callback arguments with new Timer API (#173) Test timer callback arguments with new Timer API (#173)
Uses mcrfpy.step() for synchronous test execution.
""" """
import mcrfpy import mcrfpy
import sys import sys
@ -14,9 +15,6 @@ def new_style_callback(timer, runtime):
print(f"Callback called with: timer={timer} (type: {type(timer)}), runtime={runtime} (type: {type(runtime)})") print(f"Callback called with: timer={timer} (type: {type(timer)}), runtime={runtime} (type: {type(runtime)})")
if hasattr(timer, 'once'): if hasattr(timer, 'once'):
print(f"Got Timer object! once={timer.once}") print(f"Got Timer object! once={timer.once}")
if call_count >= 2:
print("PASS")
sys.exit(0)
# Set up the scene # Set up the scene
test_scene = mcrfpy.Scene("test_scene") test_scene = mcrfpy.Scene("test_scene")
@ -25,3 +23,14 @@ test_scene.activate()
print("Testing new Timer callback signature (timer, runtime)...") print("Testing new Timer callback signature (timer, runtime)...")
timer = mcrfpy.Timer("test_timer", new_style_callback, 100) timer = mcrfpy.Timer("test_timer", new_style_callback, 100)
print(f"Timer created: {timer}") print(f"Timer created: {timer}")
# Advance time to let timer fire - each step() processes timers once
mcrfpy.step(0.15) # First fire
mcrfpy.step(0.15) # Second fire
if call_count >= 2:
print("PASS: Timer callback received correct arguments")
sys.exit(0)
else:
print(f"FAIL: Expected at least 2 callbacks, got {call_count}")
sys.exit(1)