@siteed/expo-audio-studio 2.8.6 → 2.10.0

package/android/src/test/java/net/siteed/audiostream/AudioFileHandlerTest.kt

@@ -0,0 +1,279 @@
+package net.siteed.audiostream
+
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.After
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.test.assertNotNull
+
+class AudioFileHandlerTest {
+    private lateinit var tempDir: File
+    private lateinit var audioFileHandler: AudioFileHandler
+
+    @Before
+    fun setUp() {
+        // Create a temporary directory for testing
+        tempDir = File(System.getProperty("java.io.tmpdir"), "audio_test_${System.currentTimeMillis()}")
+        tempDir.mkdirs()
+        audioFileHandler = AudioFileHandler(tempDir)
+    }
+
+    @After
+    fun tearDown() {
+        // Clean up temporary directory
+        tempDir.deleteRecursively()
+    }
+
+    @Test
+    fun testWriteWavHeader_writesCorrectHeaderFormat() {
+        // Given
+        val outputStream = ByteArrayOutputStream()
+        val sampleRate = 44100
+        val channels = 2
+        val bitDepth = 16
+
+        // When
+        audioFileHandler.writeWavHeader(outputStream, sampleRate, channels, bitDepth)
+        val header = outputStream.toByteArray()
+
+        // Then
+        assertEquals("WAV header should be 44 bytes", 44, header.size)
+        
+        // Check RIFF header
+        assertEquals("Should start with RIFF", "RIFF", String(header.sliceArray(0..3)))
+        assertEquals("Should contain WAVE identifier", "WAVE", String(header.sliceArray(8..11)))
+        assertEquals("Should contain fmt chunk", "fmt ", String(header.sliceArray(12..15)))
+        assertEquals("Should contain data chunk", "data", String(header.sliceArray(36..39)))
+        
+        // Check audio format (PCM = 1)
+        val audioFormat = ByteBuffer.wrap(header.sliceArray(20..21)).order(ByteOrder.LITTLE_ENDIAN).short
+        assertEquals("Audio format should be 1 (PCM)", 1, audioFormat.toInt())
+        
+        // Check channels
+        val headerChannels = ByteBuffer.wrap(header.sliceArray(22..23)).order(ByteOrder.LITTLE_ENDIAN).short
+        assertEquals("Channels should match", channels, headerChannels.toInt())
+        
+        // Check sample rate
+        val headerSampleRate = ByteBuffer.wrap(header.sliceArray(24..27)).order(ByteOrder.LITTLE_ENDIAN).int
+        assertEquals("Sample rate should match", sampleRate, headerSampleRate)
+        
+        // Check bit depth
+        val headerBitDepth = ByteBuffer.wrap(header.sliceArray(34..35)).order(ByteOrder.LITTLE_ENDIAN).short
+        assertEquals("Bit depth should match", bitDepth, headerBitDepth.toInt())
+    }
+
+    @Test
+    fun testWriteWavHeader_calculatesCorrectByteRate() {
+        // Given
+        val outputStream = ByteArrayOutputStream()
+        val sampleRate = 48000
+        val channels = 1
+        val bitDepth = 24
+        val expectedByteRate = sampleRate * channels * bitDepth / 8
+
+        // When
+        audioFileHandler.writeWavHeader(outputStream, sampleRate, channels, bitDepth)
+        val header = outputStream.toByteArray()
+
+        // Then
+        val byteRate = ByteBuffer.wrap(header.sliceArray(28..31)).order(ByteOrder.LITTLE_ENDIAN).int
+        assertEquals("Byte rate should be correctly calculated", expectedByteRate, byteRate)
+    }
+
+    @Test
+    fun testCreateAudioFile_createsFileWithCorrectExtension() {
+        // Given
+        val extension = "wav"
+
+        // When
+        val file = audioFileHandler.createAudioFile(extension)
+
+        // Then
+        assertNotNull("File should not be null", file)
+        assertTrue("File should exist", file.exists())
+        assertTrue("File should have correct extension", file.name.endsWith(".$extension"))
+        assertTrue("File should have correct prefix", file.name.startsWith("recording_"))
+        
+        // Clean up
+        file.delete()
+    }
+
+    @Test
+    fun testCreateAudioFile_createsUniqueFiles() {
+        // Given
+        val extension = "wav"
+
+        // When
+        val file1 = audioFileHandler.createAudioFile(extension)
+        Thread.sleep(10) // Small delay to ensure different timestamps
+        val file2 = audioFileHandler.createAudioFile(extension)
+
+        // Then
+        assertNotEquals("Files should have unique names", file1.name, file2.name)
+        assertTrue("First file should exist", file1.exists())
+        assertTrue("Second file should exist", file2.exists())
+        
+        // Clean up
+        file1.delete()
+        file2.delete()
+    }
+
+    @Test
+    fun testDeleteFile_deletesExistingFile() {
+        // Given
+        val file = audioFileHandler.createAudioFile("wav")
+        assertTrue("File should exist before deletion", file.exists())
+
+        // When
+        val result = audioFileHandler.deleteFile(file)
+
+        // Then
+        assertTrue("Delete should return true", result)
+        assertFalse("File should not exist after deletion", file.exists())
+    }
+
+    @Test
+    fun testDeleteFile_handlesNullFile() {
+        // When
+        val result = audioFileHandler.deleteFile(null)
+
+        // Then
+        assertFalse("Delete should return false for null file", result)
+    }
+
+    @Test
+    fun testDeleteFile_handlesNonExistentFile() {
+        // Given
+        val nonExistentFile = File(tempDir, "non_existent.wav")
+        assertFalse("File should not exist", nonExistentFile.exists())
+
+        // When
+        val result = audioFileHandler.deleteFile(nonExistentFile)
+
+        // Then
+        assertFalse("Delete should return false for non-existent file", result)
+    }
+
+    @Test
+    fun testClearAudioStorage_deletesAllFiles() {
+        // Given
+        val file1 = audioFileHandler.createAudioFile("wav")
+        val file2 = audioFileHandler.createAudioFile("mp3")
+        val file3 = audioFileHandler.createAudioFile("aac")
+        
+        assertTrue("File 1 should exist", file1.exists())
+        assertTrue("File 2 should exist", file2.exists())
+        assertTrue("File 3 should exist", file3.exists())
+
+        // When
+        audioFileHandler.clearAudioStorage()
+
+        // Then
+        assertFalse("File 1 should be deleted", file1.exists())
+        assertFalse("File 2 should be deleted", file2.exists())
+        assertFalse("File 3 should be deleted", file3.exists())
+        assertEquals("Directory should be empty", 0, tempDir.listFiles()?.size ?: 0)
+    }
+
+    @Test
+    fun testUpdateWavHeader_updatesFileSizeCorrectly() {
+        // Given
+        val file = audioFileHandler.createAudioFile("wav")
+        val outputStream = file.outputStream()
+        
+        // Write header
+        audioFileHandler.writeWavHeader(outputStream, 44100, 2, 16)
+        
+        // Write some audio data (1 second of silence)
+        val audioDataSize = 44100 * 2 * 2 // sampleRate * channels * bytesPerSample
+        val audioData = ByteArray(audioDataSize)
+        outputStream.write(audioData)
+        outputStream.close()
+
+        // When
+        audioFileHandler.updateWavHeader(file)
+
+        // Then
+        val updatedHeader = file.inputStream().use { it.readNBytes(44) }
+        
+        // Check file size field (bytes 4-7)
+        val fileSize = ByteBuffer.wrap(updatedHeader.sliceArray(4..7)).order(ByteOrder.LITTLE_ENDIAN).int
+        assertEquals("File size should be data size + 36", audioDataSize + 36, fileSize)
+        
+        // Check data size field (bytes 40-43)
+        val dataSize = ByteBuffer.wrap(updatedHeader.sliceArray(40..43)).order(ByteOrder.LITTLE_ENDIAN).int
+        assertEquals("Data size should match audio data size", audioDataSize, dataSize)
+        
+        // Clean up
+        file.delete()
+    }
+
+    @Test
+    fun testLoadRealWavFile_readsHeaderCorrectly() {
+        // Given - Load a real WAV file from test resources
+        val resourceStream = javaClass.classLoader?.getResourceAsStream("jfk.wav")
+        assertNotNull("Test resource jfk.wav should exist", resourceStream)
+        
+        val testFile = File(tempDir, "test_jfk.wav")
+        resourceStream?.use { input ->
+            testFile.outputStream().use { output ->
+                input.copyTo(output)
+            }
+        }
+        
+        // When - Read the WAV header
+        val header = testFile.inputStream().use { it.readNBytes(44) }
+        
+        // Then - Validate header structure
+        assertEquals("Should start with RIFF", "RIFF", String(header.sliceArray(0..3)))
+        assertEquals("Should contain WAVE identifier", "WAVE", String(header.sliceArray(8..11)))
+        assertEquals("Should contain fmt chunk", "fmt ", String(header.sliceArray(12..15)))
+        
+        // Extract audio properties
+        val channels = ByteBuffer.wrap(header.sliceArray(22..23)).order(ByteOrder.LITTLE_ENDIAN).short
+        val sampleRate = ByteBuffer.wrap(header.sliceArray(24..27)).order(ByteOrder.LITTLE_ENDIAN).int
+        val bitDepth = ByteBuffer.wrap(header.sliceArray(34..35)).order(ByteOrder.LITTLE_ENDIAN).short
+        
+        // JFK.wav is known to be mono, 16kHz, 16-bit
+        assertEquals("JFK audio should be mono", 1, channels.toInt())
+        assertEquals("JFK audio should be 16kHz", 16000, sampleRate)
+        assertEquals("JFK audio should be 16-bit", 16, bitDepth.toInt())
+        
+        // Clean up
+        testFile.delete()
+    }
+
+    @Test
+    fun testProcessMultipleRealWavFiles() {
+        // Test with different real WAV files to ensure compatibility
+        val testFiles = listOf("jfk.wav", "recorder_hello_world.wav", "osr_us_000_0010_8k.wav")
+        
+        for (fileName in testFiles) {
+            val resourceStream = javaClass.classLoader?.getResourceAsStream(fileName)
+            if (resourceStream != null) {
+                val testFile = File(tempDir, "test_$fileName")
+                resourceStream.use { input ->
+                    testFile.outputStream().use { output ->
+                        input.copyTo(output)
+                    }
+                }
+                
+                // Verify file was created and has content
+                assertTrue("$fileName should exist", testFile.exists())
+                assertTrue("$fileName should have more than just header", testFile.length() > 44)
+                
+                // Read and validate header
+                val header = testFile.inputStream().use { it.readNBytes(44) }
+                assertEquals("$fileName should have RIFF header", "RIFF", String(header.sliceArray(0..3)))
+                assertEquals("$fileName should have WAVE format", "WAVE", String(header.sliceArray(8..11)))
+                
+                // Clean up
+                testFile.delete()
+            }
+        }
+    }
+} 

package/android/src/test/java/net/siteed/audiostream/AudioFormatUtilsTest.kt

@@ -0,0 +1,273 @@
+package net.siteed.audiostream
+
+import org.junit.Test
+import org.junit.Assert.*
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.abs
+
+class AudioFormatUtilsTest {
+
+    @Test
+    fun testConvertBitDepth_8to16() {
+        // Given - 8-bit PCM data (unsigned, centered at 128)
+        val input8bit = byteArrayOf(0, 64, 128.toByte(), 192.toByte(), 255.toByte())
+        
+        // When
+        val output16bit = AudioFormatUtils.convertBitDepth(input8bit, 8, 16)
+        
+        // Then
+        val buffer = ByteBuffer.wrap(output16bit).order(ByteOrder.LITTLE_ENDIAN)
+        val samples = ShortArray(output16bit.size / 2)
+        buffer.asShortBuffer().get(samples)
+        
+        // Verify conversion (8-bit 128 = silence = 16-bit 0)
+        assertEquals("First sample should be -32768", -32768, samples[0].toInt())
+        assertEquals("Middle sample (128) should be 0", 0, samples[2].toInt())
+        assertEquals("Last sample should be 32767", 32767, samples[4].toInt())
+    }
+
+    @Test
+    fun testConvertBitDepth_16to8() {
+        // Given - 16-bit PCM data
+        val buffer16 = ByteBuffer.allocate(10).order(ByteOrder.LITTLE_ENDIAN)
+        buffer16.putShort(-32768) // Min value
+        buffer16.putShort(-16384) // -0.5
+        buffer16.putShort(0)      // Silence
+        buffer16.putShort(16384)  // 0.5
+        buffer16.putShort(32767)  // Max value
+        
+        // When
+        val output8bit = AudioFormatUtils.convertBitDepth(buffer16.array(), 16, 8)
+        
+        // Then
+        assertEquals("Should have 5 samples", 5, output8bit.size)
+        assertEquals("Min should convert to 0", 0, output8bit[0].toInt() and 0xFF)
+        assertEquals("Silence should convert to 128", 128, output8bit[2].toInt() and 0xFF)
+        assertEquals("Max should convert to 255", 255, output8bit[4].toInt() and 0xFF)
+    }
+
+    @Test
+    fun testConvertBitDepth_16to32() {
+        // Given - 16-bit PCM data
+        val buffer16 = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN)
+        buffer16.putShort(-32768) // Min
+        buffer16.putShort(0)      // Silence
+        buffer16.putShort(32767)  // Max
+        
+        // When
+        val output32bit = AudioFormatUtils.convertBitDepth(buffer16.array(), 16, 32)
+        
+        // Then
+        val buffer32 = ByteBuffer.wrap(output32bit).order(ByteOrder.LITTLE_ENDIAN)
+        assertEquals("Should have 3 32-bit samples", 12, output32bit.size)
+        
+        // Check values (scaled appropriately)
+        val sample1 = buffer32.getInt()
+        val sample2 = buffer32.getInt()
+        val sample3 = buffer32.getInt()
+        
+        assertTrue("Min value should be negative", sample1 < 0)
+        assertEquals("Silence should be 0", 0, sample2)
+        assertTrue("Max value should be positive", sample3 > 0)
+    }
+
+    @Test
+    fun testConvertBitDepth_32to16() {
+        // Given - 32-bit PCM data
+        val buffer32 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN)
+        buffer32.putInt(Int.MIN_VALUE)  // Min
+        buffer32.putInt(0)              // Silence
+        buffer32.putInt(Int.MAX_VALUE)  // Max
+        
+        // When
+        val output16bit = AudioFormatUtils.convertBitDepth(buffer32.array(), 32, 16)
+        
+        // Then
+        val buffer16 = ByteBuffer.wrap(output16bit).order(ByteOrder.LITTLE_ENDIAN)
+        assertEquals("Should have 3 16-bit samples", 6, output16bit.size)
+        
+        assertEquals("Min should convert to -32768", -32768, buffer16.getShort().toInt())
+        assertEquals("Silence should be 0", 0, buffer16.getShort().toInt())
+        assertEquals("Max should convert to 32767", 32767, buffer16.getShort().toInt())
+    }
+
+    @Test
+    fun testConvertBitDepth_sameDepth() {
+        // Given
+        val input = byteArrayOf(1, 2, 3, 4, 5, 6)
+        
+        // When - Convert 16 to 16 (no-op)
+        val output = AudioFormatUtils.convertBitDepth(input, 16, 16)
+        
+        // Then
+        assertArrayEquals("Should return same data", input, output)
+    }
+
+    @Test
+    fun testConvertBitDepth_emptyData() {
+        // Given
+        val emptyData = byteArrayOf()
+        
+        // When
+        val output = AudioFormatUtils.convertBitDepth(emptyData, 16, 32)
+        
+        // Then
+        assertEquals("Should return empty array", 0, output.size)
+    }
+
+    @Test
+    fun testConvertChannels_monoToStereo() {
+        // Given - Mono 16-bit data
+        val monoData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
+            putShort(1000)
+            putShort(2000)
+            putShort(3000)
+        }.array()
+        
+        // When
+        val stereoData = AudioFormatUtils.convertChannels(monoData, 1, 2, 16)
+        
+        // Then
+        val buffer = ByteBuffer.wrap(stereoData).order(ByteOrder.LITTLE_ENDIAN)
+        assertEquals("Should have 6 samples (3 stereo pairs)", 12, stereoData.size)
+        
+        // Each mono sample should be duplicated to both channels
+        assertEquals("L1", 1000, buffer.getShort().toInt())
+        assertEquals("R1", 1000, buffer.getShort().toInt())
+        assertEquals("L2", 2000, buffer.getShort().toInt())
+        assertEquals("R2", 2000, buffer.getShort().toInt())
+        assertEquals("L3", 3000, buffer.getShort().toInt())
+        assertEquals("R3", 3000, buffer.getShort().toInt())
+    }
+
+    @Test
+    fun testConvertChannels_stereoToMono() {
+        // Given - Stereo 16-bit data
+        val stereoData = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).apply {
+            putShort(1000)  // L1
+            putShort(2000)  // R1
+            putShort(3000)  // L2
+            putShort(4000)  // R2
+        }.array()
+        
+        // When
+        val monoData = AudioFormatUtils.convertChannels(stereoData, 2, 1, 16)
+        
+        // Then
+        val buffer = ByteBuffer.wrap(monoData).order(ByteOrder.LITTLE_ENDIAN)
+        assertEquals("Should have 2 mono samples", 4, monoData.size)
+        
+        // Each mono sample should be average of L+R
+        assertEquals("Sample 1", 1500, buffer.getShort().toInt()) // (1000+2000)/2
+        assertEquals("Sample 2", 3500, buffer.getShort().toInt()) // (3000+4000)/2
+    }
+
+    @Test
+    fun testNormalizeAudio_quietSignal() {
+        // Given - Quiet 16-bit signal
+        val quietData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
+            putShort(100)
+            putShort(-100)
+            putShort(50)
+        }.array()
+        
+        // When
+        val normalized = AudioFormatUtils.normalizeAudio(quietData, 16)
+        
+        // Then
+        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
+        val maxSample = abs(buffer.getShort().toInt())
+        buffer.rewind()
+        
+        // The loudest sample should be close to max value
+        assertTrue("Should be normalized to near max", maxSample > 30000)
+    }
+
+    @Test
+    fun testNormalizeAudio_alreadyLoud() {
+        // Given - Already loud signal
+        val loudData = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).apply {
+            putShort(32000)
+            putShort(-32000)
+        }.array()
+        
+        // When
+        val normalized = AudioFormatUtils.normalizeAudio(loudData, 16)
+        
+        // Then
+        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
+        val sample1 = abs(buffer.getShort().toInt())
+        val sample2 = abs(buffer.getShort().toInt())
+        
+        // Should be normalized but not clipped
+        assertTrue("Samples should be near max", sample1 > 32000 && sample2 > 32000)
+        assertTrue("Samples should not exceed max", sample1 <= 32767 && sample2 <= 32767)
+    }
+
+    @Test
+    fun testNormalizeAudio_silentSignal() {
+        // Given - Silent signal
+        val silentData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
+            putShort(0)
+            putShort(0)
+            putShort(0)
+        }.array()
+        
+        // When
+        val normalized = AudioFormatUtils.normalizeAudio(silentData, 16)
+        
+        // Then
+        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
+        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
+        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
+        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
+    }
+
+    @Test
+    fun testResampleAudio_upsample() {
+        // Given - 8kHz mono audio
+        val samples8k = floatArrayOf(0.0f, 0.5f, 1.0f, 0.5f, 0.0f, -0.5f, -1.0f, -0.5f)
+        
+        // When - Upsample to 16kHz
+        val samples16k = AudioFormatUtils.resampleAudio(samples8k, 8000, 16000)
+        
+        // Then
+        assertEquals("Should have approximately double samples", 16, samples16k.size)
+        // First and last samples should match
+        assertEquals("First sample", samples8k[0], samples16k[0], 0.01f)
+        assertEquals("Last sample", samples8k.last(), samples16k.last(), 0.01f)
+    }
+
+    @Test
+    fun testResampleAudio_downsample() {
+        // Given - 16kHz mono audio
+        val samples16k = floatArrayOf(
+            0.0f, 0.25f, 0.5f, 0.75f, 1.0f, 0.75f, 0.5f, 0.25f,
+            0.0f, -0.25f, -0.5f, -0.75f, -1.0f, -0.75f, -0.5f, -0.25f
+        )
+        
+        // When - Downsample to 8kHz
+        val samples8k = AudioFormatUtils.resampleAudio(samples16k, 16000, 8000)
+        
+        // Then
+        assertEquals("Should have approximately half samples", 8, samples8k.size)
+        // Check general shape is preserved
+        val maxValue = samples8k.maxOrNull() ?: 0f
+        val minValue = samples8k.minOrNull() ?: 0f
+        assertTrue("Peak should be preserved", maxValue > 0.9f)
+        assertTrue("Trough should be preserved", minValue < -0.9f)
+    }
+
+    @Test
+    fun testResampleAudio_sameRate() {
+        // Given
+        val samples = floatArrayOf(0.1f, 0.2f, 0.3f, 0.4f, 0.5f)
+        
+        // When - Same sample rate
+        val resampled = AudioFormatUtils.resampleAudio(samples, 44100, 44100)
+        
+        // Then
+        assertArrayEquals("Should return same samples", samples, resampled, 0.001f)
+    }
+} 

package/android/src/test/resources/generate_test_audio.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+Generate test WAV files for Android unit tests
+"""
+
+import wave
+import struct
+import math
+import array
+
+def generate_sine_wave(frequency, duration, sample_rate, amplitude=0.5):
+    """Generate sine wave samples"""
+    num_samples = int(duration * sample_rate)
+    samples = []
+    for i in range(num_samples):
+        t = i / sample_rate
+        value = amplitude * math.sin(2 * math.pi * frequency * t)
+        # Convert to 16-bit PCM
+        pcm_value = int(value * 32767)
+        samples.append(pcm_value)
+    return samples
+
+def create_wav_file(filename, channels, sample_rate, bit_depth, duration, frequency=440):
+    """Create a WAV file with specified parameters"""
+    print(f"Creating {filename}...")
+    
+    # Generate samples for left channel (or mono)
+    samples = generate_sine_wave(frequency, duration, sample_rate)
+    
+    # For stereo, generate right channel with different frequency
+    if channels == 2:
+        right_samples = generate_sine_wave(frequency * 1.5, duration, sample_rate)
+    
+    # Prepare the data
+    if bit_depth == 16:
+        # Create array of signed shorts
+        audio_data = array.array('h')  # signed short
+        
+        for i in range(len(samples)):
+            if channels == 1:
+                audio_data.append(samples[i])
+            else:
+                # Interleave stereo samples
+                audio_data.append(samples[i])
+                audio_data.append(right_samples[i])
+    elif bit_depth == 8:
+        # Create array of unsigned bytes
+        audio_data = array.array('B')  # unsigned char
+        
+        for i in range(len(samples)):
+            # Convert to 8-bit unsigned
+            sample_8bit = ((samples[i] + 32768) >> 8) & 0xFF
+            if channels == 1:
+                audio_data.append(sample_8bit)
+            else:
+                right_8bit = ((right_samples[i] + 32768) >> 8) & 0xFF
+                audio_data.append(sample_8bit)
+                audio_data.append(right_8bit)
+    else:
+        raise ValueError(f"Unsupported bit depth: {bit_depth}")
+    
+    # Write WAV file
+    with wave.open(filename, 'wb') as wav_file:
+        wav_file.setnchannels(channels)
+        wav_file.setsampwidth(bit_depth // 8)
+        wav_file.setframerate(sample_rate)
+        wav_file.writeframes(audio_data.tobytes())
+    
+    print(f"  Created: {filename} ({duration}s, {sample_rate}Hz, {channels}ch, {bit_depth}bit)")
+
+# Generate test files
+if __name__ == "__main__":
+    try:
+        # Basic mono file
+        create_wav_file("test_mono_16bit_44100.wav", 
+                       channels=1, sample_rate=44100, bit_depth=16, duration=1.0)
+        
+        # Stereo file
+        create_wav_file("test_stereo_16bit_48000.wav", 
+                       channels=2, sample_rate=48000, bit_depth=16, duration=1.0)
+        
+        # Short duration file
+        create_wav_file("test_short_100ms.wav", 
+                       channels=1, sample_rate=44100, bit_depth=16, duration=0.1)
+        
+        # Silent file (0 Hz frequency)
+        create_wav_file("test_silence.wav", 
+                       channels=1, sample_rate=44100, bit_depth=16, duration=0.5, frequency=0)
+        
+        print("\nAll test WAV files generated successfully!")
+    except Exception as e:
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()