@siteed/expo-audio-studio 2.18.5 → 3.0.0

package/ios/ExpoAudioStudioTests/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/ExpoAudioStudioTests/CompressedOnlyOutputTests.swift

@@ -1,294 +0,0 @@
-import XCTest
-import AVFoundation
-@testable import ExpoAudioStream
-
-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 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/ExpoAudioStudioTests/EventEmissionIntervalTests.swift

@@ -1,105 +0,0 @@
-import XCTest
-@testable import ExpoAudioStudio
-
-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)
-    }
-}

package/ios/ExpoAudioStudioTests/Info.plist

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>CFBundleDevelopmentRegion</key>
-    <string>$(DEVELOPMENT_LANGUAGE)</string>
-    <key>CFBundleExecutable</key>
-    <string>$(EXECUTABLE_NAME)</string>
-    <key>CFBundleIdentifier</key>
-    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-    <key>CFBundleInfoDictionaryVersion</key>
-    <string>6.0</string>
-    <key>CFBundleName</key>
-    <string>$(PRODUCT_NAME)</string>
-    <key>CFBundlePackageType</key>
-    <string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
-    <key>CFBundleShortVersionString</key>
-    <string>1.0</string>
-    <key>CFBundleVersion</key>
-    <string>1</string>
-</dict>
-</plist> 

package/ios/ExpoAudioStudioTests/README.md

@@ -1,39 +0,0 @@
-# ExpoAudioStudio iOS Unit Tests
-
-This directory contains unit tests for the ExpoAudioStudio iOS module.
-
-## Test Files
-
-- `AudioTestHelpers.swift` - Common test utilities and extensions
-- `AudioFormatUtilsTests.swift` - Tests for audio format utilities
-- `AudioFileHandlerTests.swift` - Tests for file handling
-- `SimpleAudioTest.swift` - Basic audio functionality tests
-- `TestAudioGenerator.swift` - Audio generation utilities for testing
-- `CompressedOnlyOutputTests.swift` - Tests for compressed-only output feature (Issue #244)
-
-## Running Tests
-
-### In Xcode
-1. Open the workspace/project containing ExpoAudioStudio
-2. Select the test target
-3. Press `Cmd+U` to run all tests or click on individual test methods
-
-### From Command Line
-```bash
-# Run all tests
-xcodebuild test -scheme ExpoAudioStudioTests -destination 'platform=iOS Simulator,name=iPhone 15'
-
-# Run specific test class
-xcodebuild test -scheme ExpoAudioStudioTests -destination 'platform=iOS Simulator,name=iPhone 15' -only-testing:ExpoAudioStudioTests/CompressedOnlyOutputTests
-```
-
-## Compressed-Only Output Tests
-
-The `CompressedOnlyOutputTests.swift` file tests the fix for Issue #244, ensuring that:
-- Compression info is properly returned when primary output is disabled
-- AAC format works correctly
-- Opus format falls back to AAC on iOS
-- Compressed file URIs are accessible
-- File sizes and metadata are correctly reported
-
-These tests verify that users can access compressed audio files even when primary WAV output is disabled.

package/ios/ExpoAudioStudioTests/SimpleAudioTest.swift

@@ -1,98 +0,0 @@
-import XCTest
-import AVFoundation
-
-class SimpleAudioTest: XCTestCase {
-    
-    func testCreateWAVHeader() {
-        // Test creating a basic WAV header
-        let sampleRate = 44100
-        let channels = 2
-        let bitsPerSample = 16
-        let dataSize = 1024
-        
-        // Calculate expected values
-        let byteRate = sampleRate * channels * (bitsPerSample / 8)
-        let blockAlign = channels * (bitsPerSample / 8)
-        
-        // Create header data manually (44 bytes)
-        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 // PCM
-        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))
-        var byteRateValue = UInt32(byteRate).littleEndian
-        header.append(Data(bytes: &byteRateValue, count: 4))
-        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))
-        
-        // Verify header size
-        XCTAssertEqual(header.count, 44, "WAV header should be 44 bytes")
-        
-        // Verify RIFF header
-        let riffHeader = String(data: header[0..<4], encoding: .ascii)
-        XCTAssertEqual(riffHeader, "RIFF")
-        
-        // Verify WAVE format
-        let waveFormat = String(data: header[8..<12], encoding: .ascii)
-        XCTAssertEqual(waveFormat, "WAVE")
-        
-        print("✅ Basic WAV header test passed!")
-    }
-    
-    func testSimpleAudioBuffer() {
-        // Test creating a simple audio buffer
-        let sampleRate = 44100.0
-        let duration = 0.1 // 100ms
-        let frequency = 440.0 // A4 note
-        
-        let frameCount = Int(sampleRate * duration)
-        let format = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!
-        
-        guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: AVAudioFrameCount(frameCount)) else {
-            XCTFail("Failed to create audio buffer")
-            return
-        }
-        
-        buffer.frameLength = AVAudioFrameCount(frameCount)
-        
-        // Generate a simple 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)
-        }
-        
-        // Verify buffer properties
-        XCTAssertEqual(buffer.frameLength, AVAudioFrameCount(frameCount))
-        XCTAssertEqual(buffer.format.sampleRate, sampleRate)
-        XCTAssertEqual(buffer.format.channelCount, 1)
-        
-        // Verify we have audio data
-        let firstSample = channelData[0]
-        let lastSample = channelData[frameCount - 1]
-        XCTAssertNotEqual(firstSample, 0.0, accuracy: 0.001)
-        XCTAssertNotEqual(lastSample, firstSample, accuracy: 0.001)
-        
-        print("✅ Simple audio buffer test passed!")
-    }
-}