feat: rate based sync

test_sync.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Test script for VLChan synchronization logic."""
+
+import sys
+from vlchan import VLChanPlayer
+
+
+def test_playback_rate_calculation():
+    """Test the playback rate calculation logic."""
+    print("Testing playback rate calculation...")
+    
+    # Create player instance to access the method
+    player = VLChanPlayer()
+    
+    # Test cases from the TypeScript implementation
+    test_cases = [
+        (0.0, 1.0),      # No difference
+        (0.1, 1.05),     # Small positive difference
+        (-0.1, 0.95),    # Small negative difference
+        (0.2, 1.05),     # Large positive difference (capped)
+        (-0.2, 0.95),    # Large negative difference (capped)
+        (1.0, 1.05),     # Very large positive difference (capped)
+        (-1.0, 0.95),    # Very large negative difference (capped)
+    ]
+    
+    for diff, expected in test_cases:
+        result = player._get_playback_rate(diff)
+        print(f"  diff={diff:6.1f}s -> rate={result:.3f} (expected {expected:.3f})")
+        assert abs(result - expected) < 0.001, f"Expected {expected}, got {result}"
+    
+    print("✓ Playback rate calculation tests passed")
+    player.cleanup()
+
+
+def test_latency_compensation():
+    """Test latency compensation logic."""
+    print("\nTesting latency compensation...")
+    
+    player = VLChanPlayer()
+    
+    # Test latency compensation
+    test_cases = [
+        (100.0, 10.0, 10.1),    # 100ms latency, 10s position -> 10.1s compensated
+        (50.0, 5.5, 5.55),      # 50ms latency, 5.5s position -> 5.55s compensated
+        (0.0, 3.0, 3.0),        # No latency
+    ]
+    
+    for latency, position, expected in test_cases:
+        # Mock the position
+        player.player.set_time(int(position * 1000))
+        result = player.get_compensated_position(latency)
+        print(f"  latency={latency:4.0f}ms, pos={position:.1f}s -> {result:.3f}s (expected {expected:.1f}s)")
+        assert abs(result - expected) < 0.01, f"Expected {expected}, got {result}"
+    
+    print("✓ Latency compensation tests passed")
+    player.cleanup()
+
+
+def test_sync_threshold_logic():
+    """Test the synchronization threshold logic."""
+    print("\nTesting sync threshold logic...")
+    
+    player = VLChanPlayer()
+    
+    # Test cases for seeking vs rate adjustment
+    test_cases = [
+        (0.5, False, "Small diff should not seek"),
+        (1.5, True, "Large diff should seek"),
+        (0.05, False, "Very small diff should not seek"),
+        (2.0, True, "Very large diff should seek"),
+    ]
+    
+    for diff, should_seek, description in test_cases:
+        seek_condition = diff > 1.0
+        print(f"  diff={diff:.2f}s -> seek={seek_condition} ({description})")
+        assert seek_condition == should_seek, f"Expected {should_seek}, got {seek_condition}"
+    
+    print("✓ Sync threshold logic tests passed")
+
+
+def main():
+    """Run all synchronization tests."""
+    print("VLChan Synchronization Test Suite")
+    print("=" * 40)
+    
+    try:
+        test_playback_rate_calculation()
+        test_latency_compensation()
+        test_sync_threshold_logic()
+        
+        print("\n" + "=" * 40)
+        print("✓ All synchronization tests passed!")
+        return 0
+        
+    except Exception as e:
+        print(f"\n✗ Test failed: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())