@siteed/expo-audio-studio 2.9.0 → 2.10.0

package/ios/AudioStreamManager.swift

@@ -546,7 +546,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         // Choose extension based on whether this is a compressed file
         let fileExtension: String
         if isCompressed {
-            fileExtension = recordingSettings?.compressedFormat.lowercased() ?? "aac"
+            fileExtension = recordingSettings?.output.compressed.format.lowercased() ?? "aac"
         } else {
             fileExtension = "wav"
         }
@@ -638,7 +638,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         }
         
         // Add compression info if enabled
-        if settings.enableCompressedOutput,
+        if settings.output.compressed.enabled,
            let compressedURL = compressedFileURL,
            FileManager.default.fileExists(atPath: compressedURL.path) {
             do {
@@ -705,8 +705,19 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             self.lastBufferTime = time
         }
         
+        // Calculate buffer size from duration if specified
+        let bufferSize: AVAudioFrameCount
+        if let duration = recordingSettings?.bufferDurationSeconds {
+            let sampleRate = inputHardwareFormat.sampleRate
+            let calculatedSize = AVAudioFrameCount(duration * sampleRate)
+            // Apply safety clamping
+            bufferSize = max(256, min(calculatedSize, 16384))
+        } else {
+            bufferSize = 1024 // Default
+        }
+        
         // Install the tap with hardware format
-        inputNode.installTap(onBus: 0, bufferSize: 1024, format: inputHardwareFormat, block: tapBlock)
+        inputNode.installTap(onBus: 0, bufferSize: bufferSize, format: inputHardwareFormat, block: tapBlock)
         Logger.debug("AudioStreamManager", "Tap installed with hardware-compatible format")
         
         // Prepare the engine if requested
@@ -768,31 +779,39 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         lastEmittedCompressedSizeAnalysis = 0
         isPaused = false
 
-        // Create recording file first
-        recordingFileURL = createRecordingFile()
-        if let url = recordingFileURL {
-            do {
-                // Ensure directory exists if needed (createRecordingFile should handle this, but belt-and-suspenders)
-                try fileManager.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true, attributes: nil)
-                // Create the file if it doesn't exist (createRecordingFile should also handle this)
-                if !fileManager.fileExists(atPath: url.path) {
-                    fileManager.createFile(atPath: url.path, contents: nil, attributes: nil)
+        // Create recording file first (unless primary output is disabled)
+        if settings.output.primary.enabled {
+            recordingFileURL = createRecordingFile()
+            if let url = recordingFileURL {
+                do {
+                    // Ensure directory exists if needed (createRecordingFile should handle this, but belt-and-suspenders)
+                    try fileManager.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true, attributes: nil)
+                    // Create the file if it doesn't exist (createRecordingFile should also handle this)
+                    if !fileManager.fileExists(atPath: url.path) {
+                        fileManager.createFile(atPath: url.path, contents: nil, attributes: nil)
+                    }
+                    // Open the handle for writing
+                    self.fileHandle = try FileHandle(forWritingTo: url)
+                    // Write initial dummy header immediately
+                    let header = createWavHeader(dataSize: 0)
+                    self.fileHandle?.write(header)
+                    self.totalDataSize = Int64(WAV_HEADER_SIZE) // Initialize size with header size
+                    Logger.debug("AudioStreamManager", "File handle opened and initial header written for \(url.path). Initial size: \(self.totalDataSize)")
+                } catch {
+                    Logger.debug("AudioStreamManager", "Error creating/opening file handle: \(error.localizedDescription)")
+                    // No need to call cleanupPreparation here, return false will handle it
+                    return false
                 }
-                // Open the handle for writing
-                self.fileHandle = try FileHandle(forWritingTo: url)
-                // Write initial dummy header immediately
-                let header = createWavHeader(dataSize: 0)
-                self.fileHandle?.write(header)
-                self.totalDataSize = Int64(WAV_HEADER_SIZE) // Initialize size with header size
-                Logger.debug("AudioStreamManager", "File handle opened and initial header written for \(url.path). Initial size: \(self.totalDataSize)")
-            } catch {
-                Logger.debug("AudioStreamManager", "Error creating/opening file handle: \(error.localizedDescription)")
-                // No need to call cleanupPreparation here, return false will handle it
+            } else {
+                Logger.debug("AudioStreamManager", "Error: Failed to create recording file URL.")
                 return false
             }
         } else {
-            Logger.debug("AudioStreamManager", "Error: Failed to create recording file URL.")
-            return false
+            // Skip file writing mode
+            recordingFileURL = nil
+            fileHandle = nil
+            totalDataSize = 0
+            Logger.debug("AudioStreamManager", "Skip file writing mode enabled - no file will be created")
         }
         
         var newSettings = settings
@@ -864,7 +883,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             Logger.debug("AudioStreamManager", "  - actual session sample rate: \(session.sampleRate)Hz") // Log actual rate
             Logger.debug("AudioStreamManager", "  - channels: \(settings.numberOfChannels)")
             Logger.debug("AudioStreamManager", "  - bit depth: \(settings.bitDepth)-bit")
-            Logger.debug("AudioStreamManager", "  - compression enabled: \(settings.enableCompressedOutput)")
+            Logger.debug("AudioStreamManager", "  - compression enabled: \(settings.output.compressed.enabled)")
 
             // Use our shared tap installation method
             let tapFormat = installTapWithHardwareFormat()
@@ -880,13 +899,13 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             audioEngine.prepare() // Prepare the engine without starting it
             
             // Setup compressed recording if enabled
-            if settings.enableCompressedOutput {
+            if settings.output.compressed.enabled {
                 // Create compressed settings
                 let compressedSettings: [String: Any] = [
-                    AVFormatIDKey: settings.compressedFormat == "aac" ? kAudioFormatMPEG4AAC : kAudioFormatOpus,
+                    AVFormatIDKey: settings.output.compressed.format == "aac" ? kAudioFormatMPEG4AAC : kAudioFormatOpus,
                     AVSampleRateKey: Float64(settings.sampleRate),
                     AVNumberOfChannelsKey: settings.numberOfChannels,
-                    AVEncoderBitRateKey: settings.compressedBitRate,
+                    AVEncoderBitRateKey: settings.output.compressed.bitrate,
                     AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue,
                     AVEncoderBitDepthHintKey: settings.bitDepth
                 ]
@@ -913,8 +932,8 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
                             } else {
                                 // Note: We don't start the recorder yet, just prepare it
                                 Logger.debug("AudioStreamManager", "Compressed recording prepared successfully")
-                                compressedFormat = settings.compressedFormat
-                                compressedBitRate = settings.compressedBitRate
+                                            compressedFormat = settings.output.compressed.format
+            compressedBitRate = settings.output.compressed.bitrate
                             }
                         }
                     } catch {
@@ -991,12 +1010,14 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             return nil
         }
         
-        guard let settings = recordingSettings, 
-              let fileUri = recordingFileURL?.absoluteString else {
-            Logger.debug("Missing settings or file URI")
+        guard let settings = recordingSettings else {
+            Logger.debug("Missing settings")
             return nil
         }
         
+        // File URI is optional when primary output is disabled
+        let fileUri = recordingFileURL?.absoluteString ?? ""
+        
         do {
             enableWakeLock()
             
@@ -1437,20 +1458,26 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         let dataToWrite = Data(bytes: bufferData, count: Int(audioData.mDataByteSize))
 
         // --- Background File Writing ---
-        // Use the persistent fileHandle opened during preparation.
-        DispatchQueue.global(qos: .utility).async { [weak self] in
-            guard let self = self, let handle = self.fileHandle else {
-                Logger.debug("BG Write Error: File handle is nil.")
-                return
-            }
-            do {
-                try handle.seekToEnd()
-                try handle.write(contentsOf: dataToWrite)
-                // Update total size state
-                self.totalDataSize += Int64(dataToWrite.count)
-            } catch {
-                 Logger.debug("BG Write Error: Failed to seek/write: \(error.localizedDescription)")
+                    // Only write to file if primary output is enabled
+            if settings.output.primary.enabled {
+            // Use the persistent fileHandle opened during preparation.
+            DispatchQueue.global(qos: .utility).async { [weak self] in
+                guard let self = self, let handle = self.fileHandle else {
+                    Logger.debug("BG Write Error: File handle is nil.")
+                    return
+                }
+                do {
+                    try handle.seekToEnd()
+                    try handle.write(contentsOf: dataToWrite)
+                    // Update total size state
+                    self.totalDataSize += Int64(dataToWrite.count)
+                } catch {
+                     Logger.debug("BG Write Error: Failed to seek/write: \(error.localizedDescription)")
+                }
             }
+        } else {
+            // Still track total size for statistics even without file writing
+            self.totalDataSize += Int64(dataToWrite.count)
         }
 
         // --- Event Emission & Analysis ---
@@ -1708,9 +1735,48 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         // Reset audio engine
         audioEngine.reset()
         
-        guard let fileURL = recordingFileURL,
-              let settings = recordingSettings else {
-            Logger.debug("Recording or file URL is nil.")
+        guard let settings = recordingSettings else {
+            Logger.debug("Recording settings is nil.")
+            stopping = false // Reset stopping flag before returning nil
+            return nil
+        }
+        
+        // For streaming-only mode (no primary output), create a result without file validation
+        if !settings.output.primary.enabled {
+            let durationMs = Int64(finalDuration * 1000)
+            let result = RecordingResult(
+                fileUri: "",
+                filename: "stream-only",
+                mimeType: mimeType,
+                duration: durationMs,
+                size: totalDataSize,
+                channels: settings.numberOfChannels,
+                bitDepth: settings.bitDepth,
+                sampleRate: settings.sampleRate,
+                compression: nil
+            )
+            
+            // Cleanup
+            recordingSettings = nil
+            startTime = nil
+            totalPausedDuration = 0
+            currentPauseStart = nil
+            lastEmissionTime = nil
+            lastEmissionTimeAnalysis = nil
+            lastEmittedSize = 0
+            lastEmittedSizeAnalysis = 0
+            lastEmittedCompressedSize = 0
+            accumulatedData.removeAll()
+            accumulatedAnalysisData.removeAll()
+            recordingUUID = nil
+            totalDataSize = 0
+            
+            stopping = false
+            return result
+        }
+        
+        guard let fileURL = recordingFileURL else {
+            Logger.debug("Recording file URL is nil.")
             stopping = false // Reset stopping flag before returning nil
             return nil
         }
@@ -1899,7 +1965,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
 
             // Get the string value from settings using the correct property name
             // The property in RecordingSettings likely matches the TS interface: deviceDisconnectionBehavior
-            let behaviorString = settings.deviceDisconnectionBehavior ?? "pause" // Use the correct property name
+            let behaviorString = settings.deviceDisconnectionBehavior.rawValue // Get the raw value from the enum
             let behavior = DeviceDisconnectionBehavior(rawValue: behaviorString) ?? .PAUSE // Convert to enum, default to .PAUSE
 
             Logger.debug("Recording device disconnected! Applying behavior: \(behavior.rawValue)")

package/ios/ExpoAudioStream.podspec

@@ -24,4 +24,10 @@ Pod::Spec.new do |s|
   }
 
   s.source_files = "**/*.{h,m,mm,swift}"
+  s.exclude_files = [
+    "*_test.swift",
+    "standalone_test.swift",
+    "tests/**/*",
+    "ExpoAudioStudioTests/**/*"
+  ]
 end

package/ios/ExpoAudioStreamModule.swift

@@ -166,19 +166,22 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                     return
                 }
                 
-                // Check if compression is enabled and format is Opus
+                // Check if output.compressed is enabled and format is Opus
                 var modifiedOptions = options
-                if let compression = options["compression"] as? [String: Any],
-                   let enabled = compression["enabled"] as? Bool, enabled,
-                   let format = compression["format"] as? String,
+                if let output = options["output"] as? [String: Any],
+                   let compressed = output["compressed"] as? [String: Any],
+                   let enabled = compressed["enabled"] as? Bool, enabled,
+                   let format = compressed["format"] as? String,
                    format.lowercased() == "opus" {
                     
-                    // Create a mutable copy of the compression dictionary
-                    var modifiedCompression = compression
+                    // Create mutable copies
+                    var modifiedOutput = output
+                    var modifiedCompressed = compressed
                     
                     // Change format to AAC and log warning
-                    modifiedCompression["format"] = "aac"
-                    modifiedOptions["compression"] = modifiedCompression
+                    modifiedCompressed["format"] = "aac"
+                    modifiedOutput["compressed"] = modifiedCompressed
+                    modifiedOptions["output"] = modifiedOutput
                     
                     Logger.warn("ExpoAudioStreamModule", "startRecording: Opus format is not supported on iOS. Falling back to AAC format.")
                 }

package/ios/ExpoAudioStudioTests/AudioFileHandlerTests.swift

@@ -0,0 +1,338 @@
+import XCTest
+import AVFoundation
+@testable import ExpoAudioStream
+
+class AudioFileHandlerTests: XCTestCase {
+    
+    var tempDir: URL!
+    var audioProcessor: AudioProcessor!
+    
+    // Helper function to create WAV header for tests
+    private func createWavHeader(sampleRate: Int, channels: Int, bitsPerSample: Int, dataSize: Int) -> Data {
+        var header = Data()
+        
+        let blockAlign = channels * (bitsPerSample / 8)
+        let byteRate = sampleRate * blockAlign
+        
+        // "RIFF" chunk descriptor
+        header.append(contentsOf: "RIFF".utf8)
+        header.append(contentsOf: UInt32(36 + dataSize).littleEndianBytes)
+        header.append(contentsOf: "WAVE".utf8)
+        
+        // "fmt " sub-chunk
+        header.append(contentsOf: "fmt ".utf8)
+        header.append(contentsOf: UInt32(16).littleEndianBytes)  // PCM format requires 16 bytes for the fmt sub-chunk
+        header.append(contentsOf: UInt16(1).littleEndianBytes)   // Audio format 1 for PCM
+        header.append(contentsOf: UInt16(channels).littleEndianBytes)
+        header.append(contentsOf: UInt32(sampleRate).littleEndianBytes)
+        header.append(contentsOf: UInt32(byteRate).littleEndianBytes)    // byteRate
+        header.append(contentsOf: UInt16(blockAlign).littleEndianBytes)  // blockAlign
+        header.append(contentsOf: UInt16(bitsPerSample).littleEndianBytes)  // bits per sample
+        
+        // "data" sub-chunk
+        header.append(contentsOf: "data".utf8)
+        header.append(contentsOf: UInt32(dataSize).littleEndianBytes)  // Sub-chunk data size
+        
+        return header
+    }
+    
+    // Helper function to update WAV header for tests
+    private func updateWavHeader(fileURL: URL) {
+        guard let fileHandle = try? FileHandle(forUpdating: fileURL) else { return }
+        defer { fileHandle.closeFile() }
+        
+        // Get file size
+        fileHandle.seekToEndOfFile()
+        let fileSize = fileHandle.offsetInFile
+        
+        // Update file size in header (bytes 4-7)
+        fileHandle.seek(toFileOffset: 4)
+        var size = UInt32(fileSize - 8).littleEndian
+        fileHandle.write(Data(bytes: &size, count: 4))
+        
+        // Update data chunk size (bytes 40-43)
+        fileHandle.seek(toFileOffset: 40)
+        var dataSize = UInt32(fileSize - 44).littleEndian
+        fileHandle.write(Data(bytes: &dataSize, count: 4))
+    }
+}
+    
+    override func setUp() {
+        super.setUp()
+        
+        // Create temporary directory for tests
+        tempDir = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try? FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        
+        // Initialize AudioProcessor
+        audioProcessor = AudioProcessor(filesDir: tempDir)
+    }
+    
+    override func tearDown() {
+        // Clean up temporary directory
+        try? FileManager.default.removeItem(at: tempDir)
+        
+        super.tearDown()
+    }
+    
+    // MARK: - WAV Header Tests
+    
+    func testWriteWavHeader_createsValidHeader() {
+        // Given
+        let sampleRate = 44100
+        let channels = 2
+        let bitsPerSample = 16
+        let dataSize = 1000
+        
+        // When
+        let header = createWavHeader(
+            sampleRate: sampleRate,
+            channels: channels,
+            bitsPerSample: bitsPerSample,
+            dataSize: dataSize
+        )
+        
+        // Then
+        XCTAssertEqual(header.count, 44, "WAV header should be 44 bytes")
+        
+        // Verify RIFF header
+        let riffString = String(data: header[0..<4], encoding: .ascii)
+        XCTAssertEqual(riffString, "RIFF")
+        
+        // Verify WAVE format
+        let waveString = String(data: header[8..<12], encoding: .ascii)
+        XCTAssertEqual(waveString, "WAVE")
+        
+        // Verify fmt chunk
+        let fmtString = String(data: header[12..<16], encoding: .ascii)
+        XCTAssertEqual(fmtString, "fmt ")
+        
+        // Verify data chunk
+        let dataString = String(data: header[36..<40], encoding: .ascii)
+        XCTAssertEqual(dataString, "data")
+    }
+    
+    func testCreateAudioFile_createsFileWithCorrectSize() {
+        // Given
+        let fileName = "test_audio.wav"
+        let sampleRate = 16000
+        let channels = 1
+        let durationMs = 1000
+        
+        // When
+        let result = audioProcessor.createAudioFile(
+            fileName: fileName,
+            sampleRate: sampleRate,
+            channels: channels,
+            durationMs: durationMs
+        )
+        
+        // Then
+        XCTAssertTrue(result["success"] as? Bool ?? false)
+        
+        let fileUri = result["fileUri"] as? String
+        XCTAssertNotNil(fileUri)
+        
+        if let fileUri = fileUri {
+            let fileURL = URL(string: fileUri)!
+            let fileExists = FileManager.default.fileExists(atPath: fileURL.path)
+            XCTAssertTrue(fileExists)
+            
+            // Verify file size
+            if let attributes = try? FileManager.default.attributesOfItem(atPath: fileURL.path),
+               let fileSize = attributes[.size] as? Int64 {
+                let expectedDataSize = sampleRate * channels * 2 * durationMs / 1000
+                let expectedFileSize = 44 + expectedDataSize // WAV header + data
+                XCTAssertEqual(fileSize, Int64(expectedFileSize))
+            }
+        }
+    }
+    
+    func testDeleteAudioFile_removesExistingFile() {
+        // Given - Create a file first
+        let fileName = "test_to_delete.wav"
+        _ = audioProcessor.createAudioFile(
+            fileName: fileName,
+            sampleRate: 16000,
+            channels: 1,
+            durationMs: 100
+        )
+        
+        // When
+        let result = audioProcessor.deleteAudioFile(fileName: fileName)
+        
+        // Then
+        XCTAssertTrue(result["success"] as? Bool ?? false)
+        
+        let fileURL = tempDir.appendingPathComponent(fileName)
+        XCTAssertFalse(FileManager.default.fileExists(atPath: fileURL.path))
+    }
+    
+    func testDeleteAudioFile_handlesNonExistentFile() {
+        // Given
+        let fileName = "non_existent.wav"
+        
+        // When
+        let result = audioProcessor.deleteAudioFile(fileName: fileName)
+        
+        // Then
+        XCTAssertFalse(result["success"] as? Bool ?? true)
+        XCTAssertNotNil(result["error"])
+    }
+    
+    func testGetAudioFiles_returnsCorrectList() {
+        // Given - Create multiple files
+        let fileNames = ["file1.wav", "file2.wav", "file3.txt"]
+        
+        for fileName in fileNames {
+            if fileName.hasSuffix(".wav") {
+                _ = audioProcessor.createAudioFile(
+                    fileName: fileName,
+                    sampleRate: 16000,
+                    channels: 1,
+                    durationMs: 100
+                )
+            } else {
+                // Create non-audio file
+                let url = tempDir.appendingPathComponent(fileName)
+                try? "test".write(to: url, atomically: true, encoding: .utf8)
+            }
+        }
+        
+        // When
+        let files = audioProcessor.getAudioFiles()
+        
+        // Then
+        XCTAssertEqual(files.count, 2, "Should only return WAV files")
+        XCTAssertTrue(files.contains("file1.wav"))
+        XCTAssertTrue(files.contains("file2.wav"))
+        XCTAssertFalse(files.contains("file3.txt"))
+    }
+    
+    func testClearAudioStorage_removesAllAudioFiles() {
+        // Given - Create multiple files
+        let audioFiles = ["audio1.wav", "audio2.wav"]
+        let otherFiles = ["document.txt", "image.png"]
+        
+        for fileName in audioFiles {
+            _ = audioProcessor.createAudioFile(
+                fileName: fileName,
+                sampleRate: 16000,
+                channels: 1,
+                durationMs: 100
+            )
+        }
+        
+        for fileName in otherFiles {
+            let url = tempDir.appendingPathComponent(fileName)
+            try? "test".write(to: url, atomically: true, encoding: .utf8)
+        }
+        
+        // When
+        let result = audioProcessor.clearAudioStorage()
+        
+        // Then
+        XCTAssertTrue(result["success"] as? Bool ?? false)
+        
+        // Verify audio files are deleted
+        for fileName in audioFiles {
+            let url = tempDir.appendingPathComponent(fileName)
+            XCTAssertFalse(FileManager.default.fileExists(atPath: url.path))
+        }
+        
+        // Verify other files remain
+        for fileName in otherFiles {
+            let url = tempDir.appendingPathComponent(fileName)
+            XCTAssertTrue(FileManager.default.fileExists(atPath: url.path))
+        }
+    }
+    
+    func testUpdateWavHeader_updatesFileSizeCorrectly() {
+        // Given - Create a file
+        let fileName = "test_update.wav"
+        let createResult = audioProcessor.createAudioFile(
+            fileName: fileName,
+            sampleRate: 16000,
+            channels: 1,
+            durationMs: 1000
+        )
+        
+        guard let fileUri = createResult["fileUri"] as? String,
+              let fileURL = URL(string: fileUri) else {
+            XCTFail("Failed to create test file")
+            return
+        }
+        
+        // Simulate appending more data
+        if let fileHandle = try? FileHandle(forWritingTo: fileURL) {
+            fileHandle.seekToEndOfFile()
+            let additionalData = Data(count: 1000)
+            fileHandle.write(additionalData)
+            fileHandle.closeFile()
+        }
+        
+        // When
+        updateWavHeader(fileURL: fileURL)
+        
+        // Then - Verify header was updated
+        if let data = try? Data(contentsOf: fileURL) {
+            // Check file size in header (bytes 4-7)
+            let fileSize = data.subdata(in: 4..<8).withUnsafeBytes { $0.load(as: UInt32.self) }
+            XCTAssertEqual(fileSize, UInt32(data.count - 8))
+            
+            // Check data chunk size (bytes 40-43)
+            let dataSize = data.subdata(in: 40..<44).withUnsafeBytes { $0.load(as: UInt32.self) }
+            XCTAssertEqual(dataSize, UInt32(data.count - 44))
+        }
+    }
+    
+    // MARK: - Real File Tests
+    
+    func testLoadRealWavFile() {
+        // Load test asset
+        guard let testBundle = Bundle(for: type(of: self)).url(forResource: "jfk", withExtension: "wav") else {
+            XCTFail("Test resource jfk.wav should exist")
+            return
+        }
+        
+        // Copy to temp directory
+        let destURL = tempDir.appendingPathComponent("test_jfk.wav")
+        try? FileManager.default.copyItem(at: testBundle, to: destURL)
+        
+        // Load and verify
+        let audioData = audioProcessor.loadAudioFromAnyFormat(
+            filePath: destURL.path,
+            config: nil
+        )
+        
+        XCTAssertNotNil(audioData)
+        
+        // JFK.wav is known to be mono, 16kHz, 16-bit
+        XCTAssertEqual(audioData?.sampleRate, 16000)
+        XCTAssertEqual(audioData?.channels, 1)
+        XCTAssertEqual(audioData?.bitDepth, 16)
+        XCTAssertGreaterThan(audioData?.data.count ?? 0, 0)
+    }
+    
+    func testProcessMultipleRealFiles() {
+        let testFiles = ["jfk.wav", "recorder_hello_world.wav", "osr_us_000_0010_8k.wav"]
+        
+        for fileName in testFiles {
+            guard let testBundle = Bundle(for: type(of: self)).url(forResource: fileName.replacingOccurrences(of: ".wav", with: ""), withExtension: "wav") else {
+                print("Skipping \(fileName) - not found in test bundle")
+                continue
+            }
+            
+            let destURL = tempDir.appendingPathComponent(fileName)
+            try? FileManager.default.copyItem(at: testBundle, to: destURL)
+            
+            let audioData = audioProcessor.loadAudioFromAnyFormat(
+                filePath: destURL.path,
+                config: nil
+            )
+            
+            XCTAssertNotNil(audioData, "Should load \(fileName)")
+            XCTAssertGreaterThan(audioData?.data.count ?? 0, 0, "\(fileName) should have audio data")
+        }
+    }
+}