@siteed/audio-studio 3.0.0

package/ios/tests/standalone/audio_recording_test.swift

@@ -0,0 +1,277 @@
+#!/usr/bin/env swift
+
+import Foundation
+import AVFoundation
+
+// Simple test framework
+struct TestResult {
+    let name: String
+    let passed: Bool
+    let message: String
+}
+
+class AudioRecordingTest {
+    var results: [TestResult] = []
+    let testDir: URL
+    var audioRecorder: AVAudioRecorder?
+    
+    init() {
+        // Create a temporary directory for test files
+        let tempDir = FileManager.default.temporaryDirectory
+        testDir = tempDir.appendingPathComponent("audio_recording_test_\(UUID().uuidString)")
+        try? FileManager.default.createDirectory(at: testDir, withIntermediateDirectories: true)
+    }
+    
+    deinit {
+        // Clean up test directory
+        try? FileManager.default.removeItem(at: testDir)
+    }
+    
+    func assert(_ condition: Bool, _ message: String, file: String = #file, line: Int = #line) {
+        let testName = "\(file.split(separator: "/").last ?? ""):\(line)"
+        results.append(TestResult(name: testName, passed: condition, message: message))
+        if !condition {
+            print("❌ FAILED: \(message) at \(testName)")
+        }
+    }
+    
+    func assertEqual<T: Equatable>(_ a: T, _ b: T, _ message: String = "", file: String = #file, line: Int = #line) {
+        let passed = a == b
+        let msg = message.isEmpty ? "\(a) should equal \(b)" : message
+        assert(passed, msg, file: file, line: line)
+    }
+    
+    func run() {
+        print("🧪 Running iOS Audio Recording Tests...\n")
+        
+        // Request permission first (in a real app)
+        setupAudioSession()
+        
+        testBasicWAVRecording()
+        testCompressedRecording()
+        testRecordingSettings()
+        testFileValidation()
+        
+        // Print summary
+        let passed = results.filter { $0.passed }.count
+        let total = results.count
+        
+        print("\n📊 Test Summary:")
+        print("   Total: \(total)")
+        print("   Passed: \(passed)")
+        print("   Failed: \(total - passed)")
+        
+        if passed == total {
+            print("\n✅ All tests passed!")
+        } else {
+            print("\n❌ Some tests failed!")
+            exit(1)
+        }
+    }
+    
+    func setupAudioSession() {
+        #if os(iOS)
+        let session = AVAudioSession.sharedInstance()
+        do {
+            try session.setCategory(.playAndRecord, mode: .default)
+            try session.setActive(true)
+            print("✓ Audio session configured")
+        } catch {
+            print("⚠️  Failed to setup audio session: \(error)")
+        }
+        #else
+        print("✓ Audio session setup skipped (macOS)")
+        #endif
+    }
+    
+    func testBasicWAVRecording() {
+        print("\nTesting basic WAV recording...")
+        
+        let wavURL = testDir.appendingPathComponent("test_recording.wav")
+        
+        // Configure recording settings for WAV
+        let settings: [String: Any] = [
+            AVFormatIDKey: Int(kAudioFormatLinearPCM),
+            AVSampleRateKey: 44100.0,
+            AVNumberOfChannelsKey: 2,
+            AVLinearPCMBitDepthKey: 16,
+            AVLinearPCMIsBigEndianKey: false,
+            AVLinearPCMIsFloatKey: false
+        ]
+        
+        do {
+            // Create recorder
+            audioRecorder = try AVAudioRecorder(url: wavURL, settings: settings)
+            assert(audioRecorder != nil, "Recorder should be created")
+            
+            // Prepare and record
+            let prepared = audioRecorder!.prepareToRecord()
+            assert(prepared, "Recorder should prepare successfully")
+            
+            let started = audioRecorder!.record()
+            assert(started, "Recording should start")
+            
+            // Record for a short time
+            Thread.sleep(forTimeInterval: 0.5)
+            
+            audioRecorder!.stop()
+            
+            // Verify file exists and has content
+            assert(FileManager.default.fileExists(atPath: wavURL.path), "WAV file should exist")
+            
+            let attributes = try FileManager.default.attributesOfItem(atPath: wavURL.path)
+            let fileSize = attributes[.size] as? Int64 ?? 0
+            assert(fileSize > 44, "WAV file should have content beyond header")
+            
+            // Verify WAV header
+            let data = try Data(contentsOf: wavURL)
+            let riffHeader = String(data: data[0..<4], encoding: .ascii)
+            assertEqual(riffHeader, "RIFF", "Should have RIFF header")
+            
+            let waveFormat = String(data: data[8..<12], encoding: .ascii)
+            assertEqual(waveFormat, "WAVE", "Should have WAVE format")
+            
+            print("✓ Basic WAV recording test completed")
+            
+        } catch {
+            assert(false, "Recording failed: \(error)")
+        }
+    }
+    
+    func testCompressedRecording() {
+        print("\nTesting compressed recording (AAC)...")
+        
+        let aacURL = testDir.appendingPathComponent("test_recording.m4a")
+        
+        // Configure recording settings for AAC
+        let settings: [String: Any] = [
+            AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
+            AVSampleRateKey: 44100.0,
+            AVNumberOfChannelsKey: 2,
+            AVEncoderBitRateKey: 128000,
+            AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
+        ]
+        
+        do {
+            // Create recorder
+            audioRecorder = try AVAudioRecorder(url: aacURL, settings: settings)
+            assert(audioRecorder != nil, "AAC recorder should be created")
+            
+            // Record
+            let started = audioRecorder!.record()
+            assert(started, "AAC recording should start")
+            
+            Thread.sleep(forTimeInterval: 0.5)
+            audioRecorder!.stop()
+            
+            // Verify file
+            assert(FileManager.default.fileExists(atPath: aacURL.path), "AAC file should exist")
+            
+            let attributes = try FileManager.default.attributesOfItem(atPath: aacURL.path)
+            let fileSize = attributes[.size] as? Int64 ?? 0
+            assert(fileSize > 0, "AAC file should have content")
+            
+            // Verify it's a valid audio file by loading it
+            let audioFile = try AVAudioFile(forReading: aacURL)
+            assert(audioFile.length > 0, "AAC file should have audio frames")
+            assertEqual(Int(audioFile.fileFormat.sampleRate), 44100, "Sample rate should match")
+            
+            print("✓ Compressed recording test completed")
+            
+        } catch {
+            assert(false, "AAC recording failed: \(error)")
+        }
+    }
+    
+    func testRecordingSettings() {
+        print("\nTesting various recording settings...")
+        
+        // Test different sample rates
+        let sampleRates = [8000.0, 16000.0, 44100.0, 48000.0]
+        
+        for sampleRate in sampleRates {
+            let url = testDir.appendingPathComponent("test_\(Int(sampleRate))hz.wav")
+            
+            let settings: [String: Any] = [
+                AVFormatIDKey: Int(kAudioFormatLinearPCM),
+                AVSampleRateKey: sampleRate,
+                AVNumberOfChannelsKey: 1,
+                AVLinearPCMBitDepthKey: 16,
+                AVLinearPCMIsBigEndianKey: false,
+                AVLinearPCMIsFloatKey: false
+            ]
+            
+            do {
+                let recorder = try AVAudioRecorder(url: url, settings: settings)
+                assert(recorder.prepareToRecord(), "Should prepare at \(sampleRate)Hz")
+                
+                // Verify settings were applied
+                let appliedSettings = recorder.settings
+                let appliedRate = appliedSettings[AVSampleRateKey] as? Double ?? 0
+                assertEqual(appliedRate, sampleRate, "Sample rate should be \(sampleRate)")
+                
+            } catch {
+                assert(false, "Failed to create recorder at \(sampleRate)Hz: \(error)")
+            }
+        }
+        
+        print("✓ Recording settings test completed")
+    }
+    
+    func testFileValidation() {
+        print("\nTesting file validation and properties...")
+        
+        // Create a test recording
+        let url = testDir.appendingPathComponent("validation_test.wav")
+        let duration = 1.0 // 1 second
+        
+        let settings: [String: Any] = [
+            AVFormatIDKey: Int(kAudioFormatLinearPCM),
+            AVSampleRateKey: 16000.0,
+            AVNumberOfChannelsKey: 1,
+            AVLinearPCMBitDepthKey: 16,
+            AVLinearPCMIsBigEndianKey: false,
+            AVLinearPCMIsFloatKey: false
+        ]
+        
+        do {
+            audioRecorder = try AVAudioRecorder(url: url, settings: settings)
+            audioRecorder!.record()
+            
+            // Record for the specified duration
+            Thread.sleep(forTimeInterval: duration)
+            audioRecorder!.stop()
+            
+            // Load and validate the file
+            let audioFile = try AVAudioFile(forReading: url)
+            
+            // Check duration (should be close to 1 second)
+            let recordedDuration = Double(audioFile.length) / audioFile.fileFormat.sampleRate
+            assert(abs(recordedDuration - duration) < 0.5, "Duration should be close to \(duration)s (got \(recordedDuration)s)")
+            
+            // Check file format
+            assertEqual(Int(audioFile.fileFormat.sampleRate), 16000, "Sample rate should be 16kHz")
+            assertEqual(Int(audioFile.fileFormat.channelCount), 1, "Should be mono")
+            
+            // Calculate expected file size
+            let expectedDataSize = Int(16000 * duration * 2) // 16kHz * 1s * 2 bytes per sample
+            let expectedFileSize = expectedDataSize + 44 // Plus WAV header
+            
+            let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
+            let actualFileSize = attributes[.size] as? Int64 ?? 0
+            
+            // Allow some tolerance (macOS may add extra metadata)
+            assert(abs(Int(actualFileSize) - expectedFileSize) < 5000, 
+                   "File size should be close to expected (\(actualFileSize) vs \(expectedFileSize))")
+            
+            print("✓ File validation test completed")
+            
+        } catch {
+            assert(false, "File validation failed: \(error)")
+        }
+    }
+}
+
+// Run the tests
+let test = AudioRecordingTest()
+test.run() 

package/ios/tests/standalone/audio_streaming_test.swift

@@ -0,0 +1,249 @@
+#!/usr/bin/env swift
+
+import Foundation
+import AVFoundation
+
+// Simple test framework
+struct TestResult {
+    let name: String
+    let passed: Bool
+    let message: String
+}
+
+class AudioStreamingTest {
+    var results: [TestResult] = []
+    let testDir: URL
+    var audioEngine: AVAudioEngine?
+    var inputNode: AVAudioInputNode?
+    
+    init() {
+        // Create a temporary directory for test files
+        let tempDir = FileManager.default.temporaryDirectory
+        testDir = tempDir.appendingPathComponent("audio_streaming_test_\(UUID().uuidString)")
+        try? FileManager.default.createDirectory(at: testDir, withIntermediateDirectories: true)
+    }
+    
+    deinit {
+        // Clean up
+        audioEngine?.stop()
+        try? FileManager.default.removeItem(at: testDir)
+    }
+    
+    func assert(_ condition: Bool, _ message: String, file: String = #file, line: Int = #line) {
+        let testName = "\(file.split(separator: "/").last ?? ""):\(line)"
+        results.append(TestResult(name: testName, passed: condition, message: message))
+        if !condition {
+            print("❌ FAILED: \(message) at \(testName)")
+        }
+    }
+    
+    func assertEqual<T: Equatable>(_ a: T, _ b: T, _ message: String = "", file: String = #file, line: Int = #line) {
+        let passed = a == b
+        let msg = message.isEmpty ? "\(a) should equal \(b)" : message
+        assert(passed, msg, file: file, line: line)
+    }
+    
+    func run() {
+        print("🧪 Running iOS Audio Streaming Tests...\n")
+        
+        testAudioEngineSetup()
+        testRealtimeStreaming()
+        testBufferProcessing()
+        testMultipleFormats()
+        
+        // Print summary
+        let passed = results.filter { $0.passed }.count
+        let total = results.count
+        
+        print("\n📊 Test Summary:")
+        print("   Total: \(total)")
+        print("   Passed: \(passed)")
+        print("   Failed: \(total - passed)")
+        
+        if passed == total {
+            print("\n✅ All tests passed!")
+        } else {
+            print("\n❌ Some tests failed!")
+            exit(1)
+        }
+    }
+    
+    func testAudioEngineSetup() {
+        print("Testing AVAudioEngine setup...")
+        
+        audioEngine = AVAudioEngine()
+        inputNode = audioEngine!.inputNode
+        
+        assert(audioEngine != nil, "Audio engine should be created")
+        assert(inputNode != nil, "Input node should be available")
+        
+        // Check input format
+        let inputFormat = inputNode!.inputFormat(forBus: 0)
+        assert(inputFormat.sampleRate > 0, "Input format should have valid sample rate")
+        assert(inputFormat.channelCount > 0, "Input format should have channels")
+        
+        print("  Sample rate: \(inputFormat.sampleRate) Hz")
+        print("  Channels: \(inputFormat.channelCount)")
+        print("  Format: \(inputFormat.commonFormat.rawValue)")
+        
+        print("✓ Audio engine setup test completed")
+    }
+    
+    func testRealtimeStreaming() {
+        print("\nTesting real-time audio streaming...")
+        
+        guard let engine = audioEngine, let input = inputNode else {
+            assert(false, "Audio engine not initialized")
+            return
+        }
+        
+        var bufferCount = 0
+        var totalFrames: AVAudioFrameCount = 0
+        let expectation = DispatchSemaphore(value: 0)
+        
+        // Install tap on input
+        let format = input.outputFormat(forBus: 0)
+        input.installTap(onBus: 0, bufferSize: 1024, format: format) { buffer, time in
+            bufferCount += 1
+            totalFrames += buffer.frameLength
+            
+            // Stop after collecting some buffers
+            if bufferCount >= 10 {
+                expectation.signal()
+            }
+        }
+        
+        do {
+            try engine.start()
+            assert(engine.isRunning, "Engine should be running")
+            
+            // Wait for buffers
+            let timeout = expectation.wait(timeout: .now() + 2.0)
+            assert(timeout == .success, "Should receive audio buffers within timeout")
+            
+            engine.stop()
+            input.removeTap(onBus: 0)
+            
+            assert(bufferCount >= 10, "Should have received at least 10 buffers")
+            assert(totalFrames > 0, "Should have received audio frames")
+            
+            print("  Received \(bufferCount) buffers")
+            print("  Total frames: \(totalFrames)")
+            
+            print("✓ Real-time streaming test completed")
+            
+        } catch {
+            assert(false, "Failed to start audio engine: \(error)")
+        }
+    }
+    
+    func testBufferProcessing() {
+        print("\nTesting buffer processing...")
+        
+        guard let engine = audioEngine, let input = inputNode else {
+            assert(false, "Audio engine not initialized")
+            return
+        }
+        
+        var processedBuffers = 0
+        var maxAmplitude: Float = 0
+        var totalRMS: Float = 0
+        let expectation = DispatchSemaphore(value: 0)
+        
+        let format = input.outputFormat(forBus: 0)
+        input.installTap(onBus: 0, bufferSize: 2048, format: format) { buffer, time in
+            // Process buffer
+            if let channelData = buffer.floatChannelData {
+                let frameLength = Int(buffer.frameLength)
+                let channelCount = Int(buffer.format.channelCount)
+                
+                for channel in 0..<channelCount {
+                    let samples = channelData[channel]
+                    
+                    // Find max amplitude
+                    for i in 0..<frameLength {
+                        let amplitude = abs(samples[i])
+                        if amplitude > maxAmplitude {
+                            maxAmplitude = amplitude
+                        }
+                    }
+                    
+                    // Calculate RMS
+                    var sum: Float = 0
+                    for i in 0..<frameLength {
+                        sum += samples[i] * samples[i]
+                    }
+                    let rms = sqrt(sum / Float(frameLength))
+                    totalRMS += rms
+                }
+            }
+            
+            processedBuffers += 1
+            if processedBuffers >= 5 {
+                expectation.signal()
+            }
+        }
+        
+        do {
+            try engine.start()
+            
+            let timeout = expectation.wait(timeout: .now() + 2.0)
+            assert(timeout == .success, "Should process buffers within timeout")
+            
+            engine.stop()
+            input.removeTap(onBus: 0)
+            
+            assert(processedBuffers >= 5, "Should have processed at least 5 buffers")
+            // Note: maxAmplitude might be 0 if there's silence
+            print("  Processed buffers: \(processedBuffers)")
+            print("  Max amplitude: \(maxAmplitude)")
+            print("  Average RMS: \(totalRMS / Float(processedBuffers))")
+            
+            print("✓ Buffer processing test completed")
+            
+        } catch {
+            assert(false, "Failed to process buffers: \(error)")
+        }
+    }
+    
+    func testMultipleFormats() {
+        print("\nTesting multiple audio formats...")
+        
+        // Test creating different format converters
+        let sampleRates = [8000.0, 16000.0, 44100.0, 48000.0]
+        
+        for sampleRate in sampleRates {
+            // Create a format
+            guard let format = AVAudioFormat(
+                commonFormat: .pcmFormatFloat32,
+                sampleRate: sampleRate,
+                channels: 1,
+                interleaved: false
+            ) else {
+                assert(false, "Failed to create format at \(sampleRate)Hz")
+                continue
+            }
+            
+            assert(format.sampleRate == sampleRate, "Format should have correct sample rate")
+            assert(format.channelCount == 1, "Format should be mono")
+            assert(format.commonFormat == .pcmFormatFloat32, "Format should be float32")
+            
+            // Test creating a buffer with this format
+            guard let buffer = AVAudioPCMBuffer(
+                pcmFormat: format,
+                frameCapacity: AVAudioFrameCount(sampleRate * 0.1) // 100ms
+            ) else {
+                assert(false, "Failed to create buffer at \(sampleRate)Hz")
+                continue
+            }
+            
+            assert(buffer.format.sampleRate == sampleRate, "Buffer format should match")
+        }
+        
+        print("✓ Multiple formats test completed")
+    }
+}
+
+// Run the tests
+let test = AudioStreamingTest()
+test.run() 

package/ios/tests/standalone/standalone_test.swift

@@ -0,0 +1,144 @@
+#!/usr/bin/env swift
+
+import Foundation
+import AVFoundation
+
+// Simple test framework
+struct TestResult {
+    let name: String
+    let passed: Bool
+    let message: String
+}
+
+class SimpleTest {
+    var results: [TestResult] = []
+    
+    func assert(_ condition: Bool, _ message: String, file: String = #file, line: Int = #line) {
+        let testName = "\(file.split(separator: "/").last ?? ""):\(line)"
+        results.append(TestResult(name: testName, passed: condition, message: message))
+        if !condition {
+            print("❌ FAILED: \(message) at \(testName)")
+        }
+    }
+    
+    func assertEqual<T: Equatable>(_ a: T, _ b: T, _ message: String = "", file: String = #file, line: Int = #line) {
+        let passed = a == b
+        let msg = message.isEmpty ? "\(a) should equal \(b)" : message
+        assert(passed, msg, file: file, line: line)
+    }
+    
+    func run() {
+        print("🧪 Running iOS Audio Tests...\n")
+        
+        testWAVHeader()
+        testAudioBuffer()
+        
+        // Print summary
+        let passed = results.filter { $0.passed }.count
+        let total = results.count
+        
+        print("\n📊 Test Summary:")
+        print("   Total: \(total)")
+        print("   Passed: \(passed)")
+        print("   Failed: \(total - passed)")
+        
+        if passed == total {
+            print("\n✅ All tests passed!")
+        } else {
+            print("\n❌ Some tests failed!")
+            exit(1)
+        }
+    }
+    
+    func testWAVHeader() {
+        print("Testing WAV header creation...")
+        
+        let sampleRate = 44100
+        let channels = 2
+        let bitsPerSample = 16
+        let dataSize = 1024
+        
+        // Create header
+        var header = Data()
+        
+        // RIFF chunk
+        header.append("RIFF".data(using: .ascii)!)
+        var fileSize = UInt32(dataSize + 36).littleEndian
+        header.append(Data(bytes: &fileSize, count: 4))
+        header.append("WAVE".data(using: .ascii)!)
+        
+        // fmt chunk
+        header.append("fmt ".data(using: .ascii)!)
+        var fmtSize = UInt32(16).littleEndian
+        header.append(Data(bytes: &fmtSize, count: 4))
+        var audioFormat = UInt16(1).littleEndian
+        header.append(Data(bytes: &audioFormat, count: 2))
+        var numChannels = UInt16(channels).littleEndian
+        header.append(Data(bytes: &numChannels, count: 2))
+        var sampleRateValue = UInt32(sampleRate).littleEndian
+        header.append(Data(bytes: &sampleRateValue, count: 4))
+        let byteRate = sampleRate * channels * (bitsPerSample / 8)
+        var byteRateValue = UInt32(byteRate).littleEndian
+        header.append(Data(bytes: &byteRateValue, count: 4))
+        let blockAlign = channels * (bitsPerSample / 8)
+        var blockAlignValue = UInt16(blockAlign).littleEndian
+        header.append(Data(bytes: &blockAlignValue, count: 2))
+        var bitsPerSampleValue = UInt16(bitsPerSample).littleEndian
+        header.append(Data(bytes: &bitsPerSampleValue, count: 2))
+        
+        // data chunk
+        header.append("data".data(using: .ascii)!)
+        var dataSizeValue = UInt32(dataSize).littleEndian
+        header.append(Data(bytes: &dataSizeValue, count: 4))
+        
+        // Tests
+        assertEqual(header.count, 44, "WAV header should be 44 bytes")
+        
+        let riffHeader = String(data: header[0..<4], encoding: .ascii)
+        assertEqual(riffHeader, "RIFF", "Should have RIFF header")
+        
+        let waveFormat = String(data: header[8..<12], encoding: .ascii)
+        assertEqual(waveFormat, "WAVE", "Should have WAVE format")
+        
+        print("✓ WAV header test completed")
+    }
+    
+    func testAudioBuffer() {
+        print("\nTesting audio buffer creation...")
+        
+        let sampleRate = 44100.0
+        let duration = 0.1
+        let frequency = 440.0
+        
+        let frameCount = Int(sampleRate * duration)
+        let format = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!
+        
+        guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: AVAudioFrameCount(frameCount)) else {
+            assert(false, "Failed to create audio buffer")
+            return
+        }
+        
+        buffer.frameLength = AVAudioFrameCount(frameCount)
+        
+        // Generate sine wave
+        let channelData = buffer.floatChannelData![0]
+        for frame in 0..<frameCount {
+            let phase = 2.0 * Double.pi * frequency * Double(frame) / sampleRate
+            channelData[frame] = Float(sin(phase) * 0.5)
+        }
+        
+        // Tests
+        assertEqual(Int(buffer.frameLength), frameCount, "Frame length should match")
+        assertEqual(buffer.format.sampleRate, sampleRate, "Sample rate should match")
+        assertEqual(Int(buffer.format.channelCount), 1, "Should have 1 channel")
+        
+        let middleSample = channelData[frameCount / 4]
+        assert(abs(middleSample) > 0.001, "Middle sample should not be zero")
+        
+        print("✓ Audio buffer test completed")
+    }
+}
+
+// Run the tests
+let test = SimpleTest()
+test.run()