@siteed/audio-studio 3.0.0

package/ios/AudioStudioTests/AudioTestHelpers.swift

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

package/ios/AudioStudioTests/CompressedOnlyOutputTests.swift

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

package/ios/AudioStudioTests/EventEmissionIntervalTests.swift

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

package/ios/AudioStudioTests/Info.plist

@@ -0,0 +1,22 @@
+<?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/AudioStudioTests/README.md

@@ -0,0 +1,39 @@
+# AudioStudio iOS Unit Tests
+
+This directory contains unit tests for the AudioStudio 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 AudioStudio
+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 AudioStudioTests -destination 'platform=iOS Simulator,name=iPhone 15'
+
+# Run specific test class
+xcodebuild test -scheme AudioStudioTests -destination 'platform=iOS Simulator,name=iPhone 15' -only-testing:AudioStudioTests/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/AudioStudioTests/SimpleAudioTest.swift

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