@siteed/audio-studio 3.2.0-beta.1 → 3.2.0

package/ios/AudioStudioTests/AudioStreamDecoderTests.swift

@@ -1,128 +0,0 @@
-import XCTest
-@testable import AudioStudio
-
-final class AudioStreamDecoderTests: XCTestCase {
-
-    // MARK: - Sample sanitization
-
-    func testSafeFloatToInt16ReplacesNonFinite() {
-        XCTAssertEqual(safeFloatToInt16(Float.nan), 0)
-        XCTAssertEqual(safeFloatToInt16(Float.infinity), Int16.max)
-        XCTAssertEqual(safeFloatToInt16(-Float.infinity), Int16.min)
-    }
-
-    func testSafeFloatToInt16ClampsOutOfRange() {
-        XCTAssertEqual(safeFloatToInt16(2.0), Int16.max)
-        XCTAssertEqual(safeFloatToInt16(-2.0), Int16.min)
-        XCTAssertEqual(safeFloatToInt16(0.0), 0)
-    }
-
-    func testSafeFloatToInt16IdentityAtUnityIsBounded() {
-        // The previous Swift `Int16(1.0 * Float(Int16.max))` trap requires
-        // the result of the multiplication to fit Int16. The new helper
-        // must produce Int16.max for sample == 1.0 without trapping.
-        XCTAssertEqual(safeFloatToInt16(1.0), Int16.max)
-        XCTAssertEqual(safeFloatToInt16(-1.0), -Int16.max)
-    }
-
-    func testSafeFloatToInt32ReplacesNonFinite() {
-        XCTAssertEqual(safeFloatToInt32(Float.nan), 0)
-        XCTAssertEqual(safeFloatToInt32(Float.infinity), Int32.max)
-        XCTAssertEqual(safeFloatToInt32(-Float.infinity), Int32.min)
-    }
-
-    func testSafeFloatToInt32ClampsOutOfRange() {
-        XCTAssertEqual(safeFloatToInt32(5.0), Int32.max)
-        XCTAssertEqual(safeFloatToInt32(-5.0), Int32.min)
-    }
-
-    // MARK: - Decoder option bounds
-
-    func testDecoderOptionsClampsChunkDuration() {
-        let opts = AudioStreamDecoder.Options(
-            requestId: "test",
-            fileUri: "/dev/null",
-            startTimeMs: nil,
-            endTimeMs: nil,
-            targetSampleRate: nil,
-            channels: nil,
-            normalizeAudio: true,
-            chunkDurationMs: 5,
-            maxChunkBytes: nil,
-            maxBufferedChunks: 0
-        )
-        XCTAssertEqual(opts.chunkDurationMs, 10, "chunkDurationMs floor is 10ms")
-        XCTAssertEqual(opts.maxBufferedChunks, 1, "maxBufferedChunks floor is 1")
-
-        let bigOpts = AudioStreamDecoder.Options(
-            requestId: "big",
-            fileUri: "/dev/null",
-            startTimeMs: nil,
-            endTimeMs: nil,
-            targetSampleRate: nil,
-            channels: nil,
-            normalizeAudio: true,
-            chunkDurationMs: 999_999,
-            maxChunkBytes: nil,
-            maxBufferedChunks: 99
-        )
-        XCTAssertEqual(bigOpts.chunkDurationMs, 60_000, "chunkDurationMs ceiling is 60s")
-    }
-
-    // MARK: - Decoder event contract
-
-    final class CaptureDelegate: AudioStreamDecoderDelegate {
-        var chunks: [[String: Any]] = []
-        var progressEvents: [[String: Any]] = []
-        var completePayload: [String: Any]?
-        var errorPayload: [String: Any]?
-        let done = XCTestExpectation(description: "decoder terminal event")
-
-        func streamDecoder(_ decoder: AudioStreamDecoder, didEmitChunk payload: [String: Any]) {
-            chunks.append(payload)
-            if let idx = payload["chunkIndex"] as? Int {
-                decoder.acknowledgeChunk(idx)
-            }
-        }
-        func streamDecoder(_ decoder: AudioStreamDecoder, didReportProgress payload: [String: Any]) {
-            progressEvents.append(payload)
-        }
-        func streamDecoder(_ decoder: AudioStreamDecoder, didCompleteWith payload: [String: Any]) {
-            completePayload = payload
-            done.fulfill()
-        }
-        func streamDecoder(_ decoder: AudioStreamDecoder, didFailWith payload: [String: Any]) {
-            errorPayload = payload
-            // Some flows emit an error then a complete; let complete fulfill.
-        }
-    }
-
-    func testDecoderEmitsFileNotFoundForMissingPath() {
-        let delegate = CaptureDelegate()
-        let opts = AudioStreamDecoder.Options(
-            requestId: "missing",
-            fileUri: "/tmp/this-file-does-not-exist-\(UUID().uuidString).wav",
-            startTimeMs: nil,
-            endTimeMs: nil,
-            targetSampleRate: nil,
-            channels: nil,
-            normalizeAudio: true,
-            chunkDurationMs: 100,
-            maxChunkBytes: nil,
-            maxBufferedChunks: 2
-        )
-        let decoder = AudioStreamDecoder(options: opts)
-        decoder.delegate = delegate
-        decoder.start()
-        // Error path never calls complete, so wait directly on the error.
-        let exp = XCTestExpectation(description: "error received")
-        DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
-            if delegate.errorPayload != nil {
-                exp.fulfill()
-            }
-        }
-        wait(for: [exp], timeout: 2.0)
-        XCTAssertEqual(delegate.errorPayload?["code"] as? String, "ERR_AUDIO_STREAM_FILE_NOT_FOUND")
-        XCTAssertEqual(delegate.errorPayload?["requestId"] as? String, "missing")
-    }
-}

package/ios/AudioStudioTests/AudioTestHelpers.swift

@@ -1,130 +0,0 @@
-import Foundation
-import AVFoundation
-import Accelerate
-
-extension AVAudioPCMBuffer {
-    
-    /// Convert buffer to Data
-    func toData() -> Data {
-        let audioFormat = self.format
-        let channelCount = Int(audioFormat.channelCount)
-        let frameLength = Int(self.frameLength)
-        
-        var data = Data()
-        
-        if let floatData = self.floatChannelData {
-            // Convert float samples to 16-bit PCM
-            for frame in 0..<frameLength {
-                for channel in 0..<channelCount {
-                    let sample = floatData[channel][frame]
-                    let int16Sample = Int16(max(-32768, min(32767, sample * 32767)))
-                    data.append(contentsOf: withUnsafeBytes(of: int16Sample) { Array($0) })
-                }
-            }
-        } else if let int16Data = self.int16ChannelData {
-            // Already 16-bit, just copy
-            for frame in 0..<frameLength {
-                for channel in 0..<channelCount {
-                    let sample = int16Data[channel][frame]
-                    data.append(contentsOf: withUnsafeBytes(of: sample) { Array($0) })
-                }
-            }
-        }
-        
-        return data
-    }
-    
-    /// Calculate RMS (Root Mean Square) of the buffer
-    func rms() -> Float {
-        guard let channelData = self.floatChannelData else { return 0 }
-        
-        let channelCount = Int(self.format.channelCount)
-        let frameLength = Int(self.frameLength)
-        
-        var sum: Float = 0
-        var sampleCount = 0
-        
-        for channel in 0..<channelCount {
-            for frame in 0..<frameLength {
-                let sample = channelData[channel][frame]
-                sum += sample * sample
-                sampleCount += 1
-            }
-        }
-        
-        return sqrt(sum / Float(sampleCount))
-    }
-    
-    /// Calculate energy of the buffer
-    func energy() -> Float {
-        guard let channelData = self.floatChannelData else { return 0 }
-        
-        let channelCount = Int(self.format.channelCount)
-        let frameLength = Int(self.frameLength)
-        
-        var sum: Float = 0
-        
-        for channel in 0..<channelCount {
-            for frame in 0..<frameLength {
-                let sample = channelData[channel][frame]
-                sum += sample * sample
-            }
-        }
-        
-        return sum
-    }
-}
-
-extension Data {
-    
-    /// Convert PCM data to float array
-    func toFloatArray(bitDepth: Int = 16) -> [Float] {
-        var floats = [Float]()
-        
-        switch bitDepth {
-        case 16:
-            let samples = self.withUnsafeBytes { $0.bindMemory(to: Int16.self) }
-            for sample in samples {
-                floats.append(Float(sample) / Float(Int16.max))
-            }
-        case 32:
-            let samples = self.withUnsafeBytes { $0.bindMemory(to: Int32.self) }
-            for sample in samples {
-                floats.append(Float(sample) / Float(Int32.max))
-            }
-        default:
-            break
-        }
-        
-        return floats
-    }
-    
-    /// Calculate RMS from PCM data
-    func rms(bitDepth: Int = 16) -> Float {
-        let floats = toFloatArray(bitDepth: bitDepth)
-        guard !floats.isEmpty else { return 0 }
-        
-        let sum = floats.reduce(0) { $0 + $1 * $1 }
-        return sqrt(sum / Float(floats.count))
-    }
-    
-    /// Calculate energy from PCM data
-    func energy(bitDepth: Int = 16) -> Float {
-        let floats = toFloatArray(bitDepth: bitDepth)
-        return floats.reduce(0) { $0 + $1 * $1 }
-    }
-}
-
-// Test assertion helpers
-extension XCTestCase {
-    
-    /// Assert two float values are approximately equal
-    func XCTAssertApproximatelyEqual(_ value1: Float, _ value2: Float, tolerance: Float = 0.0001, _ message: String = "", file: StaticString = #file, line: UInt = #line) {
-        XCTAssertLessThanOrEqual(abs(value1 - value2), tolerance, message, file: file, line: line)
-    }
-    
-    /// Assert two double values are approximately equal
-    func XCTAssertApproximatelyEqual(_ value1: Double, _ value2: Double, tolerance: Double = 0.0001, _ message: String = "", file: StaticString = #file, line: UInt = #line) {
-        XCTAssertLessThanOrEqual(abs(value1 - value2), tolerance, message, file: file, line: line)
-    }
-} 

package/ios/AudioStudioTests/CompressedOnlyOutputTests.swift

@@ -1,334 +0,0 @@
-import XCTest
-import AVFoundation
-@testable import AudioStudio
-
-class CompressedOnlyOutputTests: XCTestCase {
-    
-    var audioManager: AudioStreamManager!
-    var testDelegate: TestAudioStreamDelegate!
-    
-    override func setUp() {
-        super.setUp()
-        audioManager = AudioStreamManager()
-        testDelegate = TestAudioStreamDelegate()
-        audioManager.delegate = testDelegate
-    }
-    
-    override func tearDown() {
-        audioManager.stopRecording()
-        audioManager = nil
-        testDelegate = nil
-        super.tearDown()
-    }
-    
-    // MARK: - Test Compressed-Only Output (Issue #244)
-
-    func testAACCompressedSampleRateFallsBackForLowRequestedRate() {
-        XCTAssertEqual(
-            AudioStreamManager.compatibleAACCompressedSampleRate(
-                requestedSampleRate: 16000,
-                sessionSampleRate: 48000
-            ),
-            48000,
-            "Low requested sample rates should use the active session rate when it is AAC-compatible"
-        )
-
-        XCTAssertEqual(
-            AudioStreamManager.compatibleAACCompressedSampleRate(
-                requestedSampleRate: 16000,
-                sessionSampleRate: 0
-            ),
-            44100,
-            "Low requested sample rates should never be passed directly to AVAudioRecorder for AAC"
-        )
-    }
-
-    func testAACCompressedSampleRateKeepsCompatibleRequestedRate() {
-        XCTAssertEqual(
-            AudioStreamManager.compatibleAACCompressedSampleRate(
-                requestedSampleRate: 44100,
-                sessionSampleRate: 48000
-            ),
-            44100,
-            "Already-compatible requested sample rates should preserve existing behavior"
-        )
-
-        XCTAssertEqual(
-            AudioStreamManager.compatibleAACCompressedSampleRate(
-                requestedSampleRate: 48000,
-                sessionSampleRate: 44100
-            ),
-            48000,
-            "High requested sample rates should not be reduced to the session rate"
-        )
-    }
-    
-    func testCompressedOnlyOutputWithAAC() {
-        // Given: Recording settings with primary disabled and compressed enabled (AAC)
-        var settings = RecordingSettings(
-            sampleRate: 44100,
-            desiredSampleRate: 44100,
-            autoResumeAfterInterruption: false
-        )
-        settings.numberOfChannels = 1
-        settings.bitDepth = 16
-        settings.output.primary.enabled = false
-        settings.output.compressed.enabled = true
-        settings.output.compressed.format = "aac"
-        settings.output.compressed.bitrate = 128000
-        
-        let expectation = self.expectation(description: "Recording should complete with compression info")
-        var capturedCompressionInfo: [String: Any]?
-        var capturedError: String?
-        
-        // When: Start and stop recording
-        testDelegate.onAudioData = { data, recordingTime, totalDataSize, compressionInfo in
-            capturedCompressionInfo = compressionInfo
-        }
-        
-        testDelegate.onError = { error in
-            capturedError = error
-        }
-        
-        // Start recording returns a result that we can check
-        let startResult = audioManager.startRecording(settings: settings)
-        XCTAssertNotNil(startResult, "Start recording should return a result")
-        
-        // Generate and process some test audio to ensure compression happens
-        let testBuffer = TestAudioGenerator.generateTone(frequency: 440, duration: 0.1, sampleRate: 44100)
-        if let buffer = testBuffer {
-            // Process multiple chunks to ensure we have enough data
-            for _ in 0..<5 {
-                audioManager.processAudioBuffer(buffer, time: AVAudioTime(hostTime: mach_absolute_time()))
-                Thread.sleep(forTimeInterval: 0.1)
-            }
-        }
-        
-        // Stop recording and get the result
-        let recordingResult = audioManager.stopRecording()
-        expectation.fulfill()
-        
-        waitForExpectations(timeout: 2.0) { error in
-            XCTAssertNil(error, "Recording should complete within timeout")
-        }
-        
-        // Then: Verify compression info is returned
-        XCTAssertNil(capturedError, "No errors should occur during recording")
-        XCTAssertNotNil(recordingResult, "Recording result should not be nil")
-        XCTAssertNotNil(recordingResult?.compression, "Compression info should be included")
-        
-        if let compression = recordingResult?.compression {
-            XCTAssertEqual(compression.format, "aac", "Format should be AAC")
-            XCTAssertEqual(compression.bitrate, 128000, "Bitrate should match settings")
-            XCTAssertFalse(compression.compressedFileUri.isEmpty, "Compressed file URI should not be empty")
-            XCTAssertGreaterThan(compression.size, 0, "Compressed file size should be greater than 0")
-            XCTAssertEqual(compression.mimeType, "audio/aac", "MIME type should be audio/aac")
-        }
-        
-        // Verify main result uses compressed info when primary is disabled
-        XCTAssertEqual(recordingResult?.fileUri, recordingResult?.compression?.compressedFileUri,
-                      "Main fileUri should use compressed URI when primary is disabled")
-        XCTAssertEqual(recordingResult?.mimeType, "audio/aac",
-                      "Main mimeType should reflect compressed format")
-    }
-    
-    func testCompressedOnlyOutputWithOpusFallback() {
-        // Given: Recording settings with primary disabled and compressed enabled (Opus)
-        var settings = RecordingSettings(
-            sampleRate: 48000,
-            desiredSampleRate: 48000,
-            autoResumeAfterInterruption: false
-        )
-        settings.numberOfChannels = 1
-        settings.bitDepth = 16
-        settings.output.primary.enabled = false
-        settings.output.compressed.enabled = true
-        settings.output.compressed.format = "opus" // Should fallback to AAC on iOS
-        settings.output.compressed.bitrate = 64000
-        
-        let expectation = self.expectation(description: "Recording should complete with AAC fallback")
-        
-        // Start recording
-        let startResult = audioManager.startRecording(settings: settings)
-        XCTAssertNotNil(startResult, "Start recording should return a result")
-        
-        // Generate test audio
-        if let buffer = TestAudioGenerator.generateTone(frequency: 440, duration: 0.1, sampleRate: 48000) {
-            for _ in 0..<3 {
-                audioManager.processAudioBuffer(buffer, time: AVAudioTime(hostTime: mach_absolute_time()))
-                Thread.sleep(forTimeInterval: 0.1)
-            }
-        }
-        
-        // Stop recording
-        let recordingResult = audioManager.stopRecording()
-        expectation.fulfill()
-        
-        waitForExpectations(timeout: 2.0) { error in
-            XCTAssertNil(error, "Recording should complete within timeout")
-        }
-        
-        // Then: Verify Opus falls back to AAC on iOS
-        XCTAssertNotNil(recordingResult?.compression, "Compression info should be included")
-        XCTAssertEqual(recordingResult?.compression?.format, "aac", 
-                      "Opus should fallback to AAC on iOS")
-        XCTAssertEqual(recordingResult?.compression?.bitrate, 64000,
-                      "Bitrate should be preserved from original settings")
-    }
-    
-    func testCompressedFileAccessibility() {
-        // Given: Recording with compressed output
-        var settings = RecordingSettings(
-            sampleRate: 44100,
-            desiredSampleRate: 44100,
-            autoResumeAfterInterruption: false
-        )
-        settings.numberOfChannels = 1
-        settings.bitDepth = 16
-        settings.output.primary.enabled = false
-        settings.output.compressed.enabled = true
-        settings.output.compressed.format = "aac"
-        settings.output.compressed.bitrate = 96000
-        
-        let expectation = self.expectation(description: "Compressed file should be accessible")
-        
-        // Start recording
-        let startResult = audioManager.startRecording(settings: settings)
-        XCTAssertNotNil(startResult, "Start recording should return a result")
-        
-        // Generate substantial audio data to ensure file is created
-        if let buffer = TestAudioGenerator.generateTone(frequency: 440, duration: 0.2, sampleRate: 44100) {
-            for _ in 0..<5 {
-                audioManager.processAudioBuffer(buffer, time: AVAudioTime(hostTime: mach_absolute_time()))
-                Thread.sleep(forTimeInterval: 0.1)
-            }
-        }
-        
-        // Stop recording
-        let recordingResult = audioManager.stopRecording()
-        expectation.fulfill()
-        
-        waitForExpectations(timeout: 2.0) { error in
-            XCTAssertNil(error, "Recording should complete within timeout")
-        }
-        
-        // Then: Verify compressed file is accessible
-        if let compression = recordingResult?.compression {
-            let fileURL = URL(string: compression.compressedFileUri)
-            XCTAssertNotNil(fileURL, "Compressed file URL should be valid")
-            
-            if let url = fileURL {
-                let fileExists = FileManager.default.fileExists(atPath: url.path)
-                XCTAssertTrue(fileExists, "Compressed file should exist at the specified path")
-                
-                // Verify file size matches reported size
-                if fileExists {
-                    do {
-                        let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
-                        let actualSize = attributes[.size] as? Int64 ?? 0
-                        XCTAssertEqual(actualSize, compression.size,
-                                      "Reported size should match actual file size")
-                    } catch {
-                        XCTFail("Failed to get file attributes: \(error)")
-                    }
-                }
-            }
-        } else {
-            XCTFail("Compression info should not be nil")
-        }
-    }
-    
-    func testStreamingOnlyWithCompression() {
-        // Given: Streaming configuration with compression
-        var settings = RecordingSettings(
-            sampleRate: 44100,
-            desiredSampleRate: 44100,
-            autoResumeAfterInterruption: false
-        )
-        settings.numberOfChannels = 1
-        settings.bitDepth = 16
-        settings.output.primary.enabled = false
-        settings.output.compressed.enabled = true
-        settings.output.compressed.format = "aac"
-        settings.output.compressed.bitrate = 128000
-        settings.interval = 100 // Enable streaming with 100ms intervals
-        
-        let expectation = self.expectation(description: "Streaming should work with compressed output")
-        var dataEventCount = 0
-        var hasCompressionInfo = false
-        
-        testDelegate.onAudioData = { data, recordingTime, totalDataSize, compressionInfo in
-            dataEventCount += 1
-            if compressionInfo != nil {
-                hasCompressionInfo = true
-            }
-        }
-        
-        // Start recording
-        let startResult = audioManager.startRecording(settings: settings)
-        XCTAssertNotNil(startResult, "Start recording should return a result")
-        
-        // Generate audio data
-        if let buffer = TestAudioGenerator.generateTone(frequency: 440, duration: 0.1, sampleRate: 44100) {
-            for _ in 0..<5 {
-                audioManager.processAudioBuffer(buffer, time: AVAudioTime(hostTime: mach_absolute_time()))
-                Thread.sleep(forTimeInterval: 0.1)
-            }
-        }
-        
-        // Stop recording
-        let recordingResult = audioManager.stopRecording()
-        expectation.fulfill()
-        
-        waitForExpectations(timeout: 2.0) { error in
-            XCTAssertNil(error, "Recording should complete within timeout")
-        }
-        
-        // Then: Verify streaming worked and compression info is available
-        XCTAssertGreaterThan(dataEventCount, 0, "Should have received audio data events")
-        XCTAssertTrue(hasCompressionInfo, "Should have received compression info in data events")
-        XCTAssertNotNil(recordingResult?.compression, "Compression info should be available in final result")
-    }
-}
-
-// MARK: - Test Delegate
-
-class TestAudioStreamDelegate: AudioStreamManagerDelegate {
-    var onAudioData: ((Data, TimeInterval, Int64, [String: Any]?) -> Void)?
-    var onError: ((String) -> Void)?
-    var onAnalysis: ((AudioAnalysisData?) -> Void)?
-    
-    func audioStreamManager(
-        _ manager: AudioStreamManager,
-        didReceiveAudioData data: Data,
-        recordingTime: TimeInterval,
-        totalDataSize: Int64,
-        compressionInfo: [String: Any]?
-    ) {
-        onAudioData?(data, recordingTime, totalDataSize, compressionInfo)
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didReceiveProcessingResult result: AudioAnalysisData?) {
-        onAnalysis?(result)
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didPauseRecording pauseTime: Date) {
-        // Optional: Handle pause
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didResumeRecording resumeTime: Date) {
-        // Optional: Handle resume
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didUpdateNotificationState isPaused: Bool) {
-        // Optional: Handle notification state
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didReceiveInterruption info: [String: Any]) {
-        // Optional: Handle interruption
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didFailWithError error: String) {
-        onError?(error)
-    }
-}

package/ios/AudioStudioTests/EventEmissionIntervalTests.swift

@@ -1,105 +0,0 @@
-import XCTest
-@testable import AudioStudio
-
-class EventEmissionIntervalTests: XCTestCase {
-    
-    var audioStreamManager: AudioStreamManager!
-    
-    override func setUp() {
-        super.setUp()
-        audioStreamManager = AudioStreamManager()
-    }
-    
-    override func tearDown() {
-        audioStreamManager = nil
-        super.tearDown()
-    }
-    
-    func testIntervalClamping() {
-        // Test case 1: Interval below minimum (10ms)
-        let config1 = RecordingConfig()
-        config1.interval = 10
-        config1.intervalAnalysis = 10
-        
-        audioStreamManager.prepareRecording(with: config1) { error in
-            XCTAssertNil(error, "Should prepare successfully")
-        }
-        
-        // After our fix, this should be 10ms (0.01s), not 100ms (0.1s)
-        XCTAssertEqual(audioStreamManager.emissionInterval, 0.01, accuracy: 0.001)
-        XCTAssertEqual(audioStreamManager.emissionIntervalAnalysis, 0.01, accuracy: 0.001)
-        
-        // Test case 2: Interval at old minimum (100ms)
-        let config2 = RecordingConfig()
-        config2.interval = 100
-        config2.intervalAnalysis = 100
-        
-        audioStreamManager.prepareRecording(with: config2) { error in
-            XCTAssertNil(error, "Should prepare successfully")
-        }
-        
-        XCTAssertEqual(audioStreamManager.emissionInterval, 0.1, accuracy: 0.001)
-        XCTAssertEqual(audioStreamManager.emissionIntervalAnalysis, 0.1, accuracy: 0.001)
-        
-        // Test case 3: Interval above minimum (200ms)
-        let config3 = RecordingConfig()
-        config3.interval = 200
-        config3.intervalAnalysis = 200
-        
-        audioStreamManager.prepareRecording(with: config3) { error in
-            XCTAssertNil(error, "Should prepare successfully")
-        }
-        
-        XCTAssertEqual(audioStreamManager.emissionInterval, 0.2, accuracy: 0.001)
-        XCTAssertEqual(audioStreamManager.emissionIntervalAnalysis, 0.2, accuracy: 0.001)
-    }
-    
-    func testEventEmissionTiming() {
-        let expectation = self.expectation(description: "Should emit events at correct intervals")
-        var eventTimestamps: [TimeInterval] = []
-        let testDuration: TimeInterval = 0.5 // 500ms
-        
-        // Configure for 10ms intervals
-        let config = RecordingConfig()
-        config.interval = 10
-        config.intervalAnalysis = 10
-        config.enableProcessing = true
-        config.features = ["fft": true]
-        
-        // Mock event handler to capture timestamps
-        audioStreamManager.onAudioData = { _ in
-            eventTimestamps.append(Date().timeIntervalSince1970)
-        }
-        
-        audioStreamManager.startRecording(with: config) { error in
-            XCTAssertNil(error, "Should start recording successfully")
-            
-            // Record for test duration
-            DispatchQueue.main.asyncAfter(deadline: .now() + testDuration) {
-                self.audioStreamManager.stopRecording()
-                
-                // Analyze intervals
-                if eventTimestamps.count > 1 {
-                    var intervals: [TimeInterval] = []
-                    for i in 1..<eventTimestamps.count {
-                        intervals.append((eventTimestamps[i] - eventTimestamps[i-1]) * 1000) // Convert to ms
-                    }
-                    
-                    let avgInterval = intervals.reduce(0, +) / Double(intervals.count)
-                    let minInterval = intervals.min() ?? 0
-                    let maxInterval = intervals.max() ?? 0
-                    
-                    print("Event emission intervals - Avg: \(avgInterval)ms, Min: \(minInterval)ms, Max: \(maxInterval)ms")
-                    
-                    // With the fix, average should be close to 10ms
-                    XCTAssertLessThan(abs(avgInterval - 10), 5, "Average interval should be close to 10ms")
-                    XCTAssertGreaterThan(minInterval, 5, "Minimum interval should be at least 5ms")
-                }
-                
-                expectation.fulfill()
-            }
-        }
-        
-        waitForExpectations(timeout: testDuration + 1.0)
-    }
-}