Spaces:
Sleeping
Sleeping
| #!/usr/bin/env python3 | |
| """ | |
| Unit tests for VAD module | |
| """ | |
| import pytest | |
| import torch | |
| import numpy as np | |
| from pathlib import Path | |
| import sys | |
| # Add src to path | |
| sys.path.insert(0, str(Path(__file__).parent.parent)) | |
| from src.vad import SileroVAD | |
| class TestSileroVAD: | |
| """Test cases for Silero VAD.""" | |
| def vad(self): | |
| """Create VAD instance for testing.""" | |
| return SileroVAD(threshold=0.5) | |
| def test_initialization(self, vad): | |
| """Test VAD initialization.""" | |
| assert vad is not None | |
| assert vad.threshold == 0.5 | |
| assert vad.sampling_rate == 16000 | |
| assert vad.model is not None | |
| def test_process_chunk(self, vad): | |
| """Test processing a single audio chunk.""" | |
| # Create test audio | |
| chunk = np.random.randn(1536).astype(np.float32) | |
| # Process | |
| prob = vad.process_chunk(chunk) | |
| # Verify | |
| assert isinstance(prob, float) | |
| assert 0.0 <= prob <= 1.0 | |
| def test_get_speech_timestamps(self, vad): | |
| """Test getting speech timestamps.""" | |
| # Create test audio with speech-like pattern | |
| sr = 16000 | |
| duration = 5 | |
| audio = np.zeros(sr * duration, dtype=np.float32) | |
| # Add "speech" in middle (higher energy) | |
| audio[sr:sr*3] = 0.5 * np.random.randn(sr * 2) | |
| # Get timestamps | |
| timestamps = vad.get_speech_timestamps(audio, return_seconds=True) | |
| # Verify | |
| assert isinstance(timestamps, list) | |
| for ts in timestamps: | |
| assert 'start' in ts | |
| assert 'end' in ts | |
| assert ts['end'] > ts['start'] | |
| def test_reset_states(self, vad): | |
| """Test state reset.""" | |
| # Process some audio | |
| chunk = np.random.randn(1536).astype(np.float32) | |
| vad.process_chunk(chunk) | |
| # Reset | |
| vad.reset_states() | |
| # Should work without error | |
| prob = vad.process_chunk(chunk) | |
| assert isinstance(prob, float) | |
| def test_benchmark_latency(self, vad): | |
| """Test latency benchmarking.""" | |
| metrics = vad.benchmark_latency(duration_seconds=1.0) | |
| # Verify metrics | |
| assert 'total_processing_time_ms' in metrics | |
| assert 'audio_duration_s' in metrics | |
| assert 'latency_per_second_ms' in metrics | |
| assert 'real_time_factor' in metrics | |
| # Check latency target | |
| assert metrics['latency_per_second_ms'] < 1000 # Should be much faster | |
| def test_different_thresholds(self): | |
| """Test VAD with different thresholds.""" | |
| thresholds = [0.3, 0.5, 0.7] | |
| for threshold in thresholds: | |
| vad = SileroVAD(threshold=threshold) | |
| assert vad.threshold == threshold | |
| # Test processing | |
| audio = np.random.randn(16000).astype(np.float32) | |
| timestamps = vad.get_speech_timestamps(audio) | |
| assert isinstance(timestamps, list) | |
| def test_vad_import(): | |
| """Test that VAD can be imported.""" | |
| from src.vad import SileroVAD | |
| assert SileroVAD is not None | |
| if __name__ == "__main__": | |
| pytest.main([__file__, "-v"]) | |