@siteed/expo-audio-studio 2.18.5 → 3.0.0

package/ios/ExpoAudioStudioTests/AudioFileHandlerTests.swift

@@ -1,338 +0,0 @@
-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")
-        }
-    }
-} 

package/ios/ExpoAudioStudioTests/AudioFormatUtilsTests.swift

@@ -1,331 +0,0 @@
-import XCTest
-import AVFoundation
-import Accelerate
-@testable import ExpoAudioStream
-
-class AudioFormatUtilsTests: XCTestCase {
-    
-    // MARK: - Bit Depth Conversion Tests
-    
-    func testConvertBitDepth_8to16() {
-        // Given
-        let input8bit: [UInt8] = [0, 64, 128, 192, 255]
-        let expected16bit: [Int16] = [-32768, -16384, 0, 16384, 32767]
-        
-        // When
-        let result = AudioFormatUtils.convertBitDepth(
-            data: Data(input8bit),
-            fromBitDepth: 8,
-            toBitDepth: 16
-        )
-        
-        // Then
-        let result16bit = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
-        XCTAssertEqual(result16bit, expected16bit)
-    }
-    
-    func testConvertBitDepth_16to8() {
-        // Given
-        let input16bit: [Int16] = [-32768, -16384, 0, 16384, 32767]
-        let expected8bit: [UInt8] = [0, 64, 128, 192, 255]
-        
-        // When
-        var data = Data()
-        input16bit.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        let result = AudioFormatUtils.convertBitDepth(
-            data: data,
-            fromBitDepth: 16,
-            toBitDepth: 8
-        )
-        
-        // Then
-        let result8bit = Array(result)
-        XCTAssertEqual(result8bit, expected8bit)
-    }
-    
-    func testConvertBitDepth_16to32() {
-        // Given
-        let input16bit: [Int16] = [-32768, 0, 32767]
-        let expected32bit: [Int32] = [-2147483648, 0, 2147483647]
-        
-        // When
-        var data = Data()
-        input16bit.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        let result = AudioFormatUtils.convertBitDepth(
-            data: data,
-            fromBitDepth: 16,
-            toBitDepth: 32
-        )
-        
-        // Then
-        let result32bit = result.withUnsafeBytes { Array($0.bindMemory(to: Int32.self)) }
-        XCTAssertEqual(result32bit, expected32bit)
-    }
-    
-    func testConvertBitDepth_32to16() {
-        // Given
-        let input32bit: [Int32] = [-2147483648, 0, 2147483647]
-        let expected16bit: [Int16] = [-32768, 0, 32767]
-        
-        // When
-        var data = Data()
-        input32bit.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        let result = AudioFormatUtils.convertBitDepth(
-            data: data,
-            fromBitDepth: 32,
-            toBitDepth: 16
-        )
-        
-        // Then
-        let result16bit = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
-        XCTAssertEqual(result16bit, expected16bit)
-    }
-    
-    func testConvertBitDepth_sameDepth() {
-        // Given
-        let input: [Int16] = [100, 200, 300]
-        var data = Data()
-        input.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.convertBitDepth(
-            data: data,
-            fromBitDepth: 16,
-            toBitDepth: 16
-        )
-        
-        // Then
-        XCTAssertEqual(result, data)
-    }
-    
-    // MARK: - Channel Conversion Tests
-    
-    func testConvertChannels_monoToStereo() {
-        // Given
-        let monoData: [Int16] = [100, 200, 300]
-        var data = Data()
-        monoData.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.convertChannels(
-            data: data,
-            fromChannels: 1,
-            toChannels: 2,
-            bitDepth: 16
-        )
-        
-        // Then
-        let stereoData = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
-        let expected: [Int16] = [100, 100, 200, 200, 300, 300]
-        XCTAssertEqual(stereoData, expected)
-    }
-    
-    func testConvertChannels_stereoToMono() {
-        // Given
-        let stereoData: [Int16] = [100, 200, 300, 400, 500, 600]
-        var data = Data()
-        stereoData.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.convertChannels(
-            data: data,
-            fromChannels: 2,
-            toChannels: 1,
-            bitDepth: 16
-        )
-        
-        // Then
-        let monoData = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
-        let expected: [Int16] = [150, 350, 550] // Average of pairs
-        XCTAssertEqual(monoData, expected)
-    }
-    
-    func testConvertChannels_sameChannels() {
-        // Given
-        let input: [Int16] = [100, 200, 300, 400]
-        var data = Data()
-        input.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.convertChannels(
-            data: data,
-            fromChannels: 2,
-            toChannels: 2,
-            bitDepth: 16
-        )
-        
-        // Then
-        XCTAssertEqual(result, data)
-    }
-    
-    // MARK: - Audio Normalization Tests
-    
-    func testNormalizeAudio_quietAudio() {
-        // Given - Very quiet audio
-        let quietAudio: [Int16] = [10, -10, 20, -20, 30, -30]
-        var data = Data()
-        quietAudio.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.normalizeAudio(
-            data: data,
-            bitDepth: 16,
-            targetLevel: 0.9
-        )
-        
-        // Then
-        let normalized = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
-        
-        // Check that audio was amplified
-        let maxOriginal = quietAudio.map { abs($0) }.max() ?? 0
-        let maxNormalized = normalized.map { abs($0) }.max() ?? 0
-        
-        XCTAssertGreaterThan(maxNormalized, maxOriginal)
-        
-        // Check that max is close to target
-        let targetMax = Int16(Float(Int16.max) * 0.9)
-        XCTAssertGreaterThan(maxNormalized, Int16(Float(targetMax) * 0.8))
-        XCTAssertLessThanOrEqual(maxNormalized, targetMax)
-    }
-    
-    func testNormalizeAudio_loudAudio() {
-        // Given - Already loud audio
-        let loudAudio: [Int16] = [30000, -30000, 25000, -25000]
-        var data = Data()
-        loudAudio.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.normalizeAudio(
-            data: data,
-            bitDepth: 16,
-            targetLevel: 0.9
-        )
-        
-        // Then
-        let normalized = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
-        
-        // Check that audio was slightly reduced
-        let maxOriginal = loudAudio.map { abs($0) }.max() ?? 0
-        let maxNormalized = normalized.map { abs($0) }.max() ?? 0
-        
-        XCTAssertLessThanOrEqual(maxNormalized, maxOriginal)
-        
-        // Check that max is close to target
-        let targetMax = Int16(Float(Int16.max) * 0.9)
-        XCTAssertGreaterThan(maxNormalized, Int16(Float(targetMax) * 0.8))
-        XCTAssertLessThanOrEqual(maxNormalized, targetMax)
-    }
-    
-    func testNormalizeAudio_silentAudio() {
-        // Given - Silent audio
-        let silentAudio = [Int16](repeating: 0, count: 100)
-        var data = Data()
-        silentAudio.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.normalizeAudio(
-            data: data,
-            bitDepth: 16,
-            targetLevel: 0.9
-        )
-        
-        // Then - Should remain silent
-        let normalized = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
-        XCTAssertTrue(normalized.allSatisfy { $0 == 0 })
-    }
-    
-    // MARK: - Sample Rate Conversion Tests
-    
-    func testResampleAudio_upsample() {
-        // Given
-        let originalSampleRate = 16000
-        let targetSampleRate = 44100
-        let duration = 0.1 // 100ms
-        let originalSamples = Int(Double(originalSampleRate) * duration)
-        
-        // Create a simple sine wave
-        var sineWave = [Int16]()
-        for i in 0..<originalSamples {
-            let value = sin(2.0 * .pi * 440.0 * Double(i) / Double(originalSampleRate))
-            sineWave.append(Int16(value * 10000))
-        }
-        
-        var data = Data()
-        sineWave.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.resampleAudio(
-            data: data,
-            fromSampleRate: originalSampleRate,
-            toSampleRate: targetSampleRate,
-            channels: 1,
-            bitDepth: 16
-        )
-        
-        // Then
-        let expectedSamples = Int(Double(targetSampleRate) * duration)
-        let actualSamples = result.count / 2 // 16-bit = 2 bytes per sample
-        
-        // Allow some tolerance due to resampling
-        XCTAssertGreaterThan(actualSamples, Int(Double(expectedSamples) * 0.95))
-        XCTAssertLessThan(actualSamples, Int(Double(expectedSamples) * 1.05))
-    }
-    
-    func testResampleAudio_downsample() {
-        // Given
-        let originalSampleRate = 44100
-        let targetSampleRate = 16000
-        let duration = 0.1 // 100ms
-        let originalSamples = Int(Double(originalSampleRate) * duration)
-        
-        // Create a simple sine wave
-        var sineWave = [Int16]()
-        for i in 0..<originalSamples {
-            let value = sin(2.0 * .pi * 440.0 * Double(i) / Double(originalSampleRate))
-            sineWave.append(Int16(value * 10000))
-        }
-        
-        var data = Data()
-        sineWave.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.resampleAudio(
-            data: data,
-            fromSampleRate: originalSampleRate,
-            toSampleRate: targetSampleRate,
-            channels: 1,
-            bitDepth: 16
-        )
-        
-        // Then
-        let expectedSamples = Int(Double(targetSampleRate) * duration)
-        let actualSamples = result.count / 2 // 16-bit = 2 bytes per sample
-        
-        // Allow some tolerance due to resampling
-        XCTAssertGreaterThan(actualSamples, Int(Double(expectedSamples) * 0.95))
-        XCTAssertLessThan(actualSamples, Int(Double(expectedSamples) * 1.05))
-    }
-    
-    func testResampleAudio_sameSampleRate() {
-        // Given
-        let sampleRate = 44100
-        let samples: [Int16] = [100, 200, 300, 400, 500]
-        var data = Data()
-        samples.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
-        
-        // When
-        let result = AudioFormatUtils.resampleAudio(
-            data: data,
-            fromSampleRate: sampleRate,
-            toSampleRate: sampleRate,
-            channels: 1,
-            bitDepth: 16
-        )
-        
-        // Then - Should return same data
-        XCTAssertEqual(result, data)
-    }
-}