wavefile 0.8.1 → 1.0.0

data/test/unvalidated_format_test.rb

@@ -12,7 +12,8 @@ class UnvalidatedFormatTest < Minitest::Test
                                     :byte_rate => 176400,
                                     :block_align => 4,
                                     :bits_per_sample => 16,
-                                    :valid_bits_per_sample => 14})
+                                    :valid_bits_per_sample => 14,
+                                    :speaker_mapping => 3})  # Bit field '11'
 
     assert_equal(65534,  format.audio_format)
     assert_equal(SUB_FORMAT_GUID_PCM, format.sub_audio_format_guid)
@@ -24,6 +25,7 @@ class UnvalidatedFormatTest < Minitest::Test
     assert_equal(4,      format.block_align)
     assert_equal(16,     format.bits_per_sample)
     assert_equal(14,     format.valid_bits_per_sample)
+    assert_equal([:front_left, :front_right], format.speaker_mapping)
   end
 
   def test_to_validated_format_pcm
@@ -41,6 +43,7 @@ class UnvalidatedFormatTest < Minitest::Test
     assert_equal(44100, validated_format.sample_rate)
     assert_equal(176400, validated_format.byte_rate)
     assert_equal(4, validated_format.block_align)
+    assert_equal([:front_left, :front_right], validated_format.speaker_mapping)
   end
 
   def test_to_validated_format_float
@@ -58,6 +61,7 @@ class UnvalidatedFormatTest < Minitest::Test
     assert_equal(44100, validated_format.sample_rate)
     assert_equal(352800, validated_format.byte_rate)
     assert_equal(8, validated_format.block_align)
+    assert_equal([:front_left, :front_right], validated_format.speaker_mapping)
   end
 
   def test_to_validated_format_unsupported
@@ -79,7 +83,8 @@ class UnvalidatedFormatTest < Minitest::Test
                                                 :byte_rate => 176400,
                                                 :block_align => 4,
                                                 :bits_per_sample => 16,
-                                                :valid_bits_per_sample => 16})
+                                                :valid_bits_per_sample => 16,
+                                                :speaker_mapping => 3})
 
     validated_format = unvalidated_format.to_validated_format
     assert_equal(:pcm, validated_format.sample_format)
@@ -88,6 +93,7 @@ class UnvalidatedFormatTest < Minitest::Test
     assert_equal(44100, validated_format.sample_rate)
     assert_equal(176400, validated_format.byte_rate)
     assert_equal(4, validated_format.block_align)
+    assert_equal([:front_left, :front_right], validated_format.speaker_mapping)
   end
 
   def test_to_validated_format_wave_format_extensible_float
@@ -98,7 +104,8 @@ class UnvalidatedFormatTest < Minitest::Test
                                                 :byte_rate => 352800,
                                                 :block_align => 8,
                                                 :bits_per_sample => 32,
-                                                :valid_bits_per_sample => 32})
+                                                :valid_bits_per_sample => 32,
+                                                :speaker_mapping => 5})
 
     validated_format = unvalidated_format.to_validated_format
     assert_equal(:float, validated_format.sample_format)
@@ -107,6 +114,7 @@ class UnvalidatedFormatTest < Minitest::Test
     assert_equal(44100, validated_format.sample_rate)
     assert_equal(352800, validated_format.byte_rate)
     assert_equal(8, validated_format.block_align)
+    assert_equal([:front_left, :front_center], validated_format.speaker_mapping)
   end
 
   def test_to_validated_format_wave_format_extensible_unsupported_sub_format
@@ -117,7 +125,8 @@ class UnvalidatedFormatTest < Minitest::Test
                                                 :byte_rate => 176400,
                                                 :block_align => 4,
                                                 :bits_per_sample => 16,
-                                                :valid_bits_per_sample => 16})
+                                                :valid_bits_per_sample => 16,
+                                                :speaker_mapping => 3})
 
     assert_raises(InvalidFormatError) { unvalidated_format.to_validated_format }
   end
@@ -130,7 +139,8 @@ class UnvalidatedFormatTest < Minitest::Test
                                                 :byte_rate => 176400,
                                                 :block_align => 4,
                                                 :bits_per_sample => 14,
-                                                :valid_bits_per_sample => 14})
+                                                :valid_bits_per_sample => 14,
+                                                :speaker_mapping => 3})
 
     assert_raises(InvalidFormatError) { unvalidated_format.to_validated_format }
   end
@@ -143,8 +153,173 @@ class UnvalidatedFormatTest < Minitest::Test
                                                 :byte_rate => 176400,
                                                 :block_align => 4,
                                                 :bits_per_sample => 16,
-                                                :valid_bits_per_sample => 14})
+                                                :valid_bits_per_sample => 14,
+                                                :speaker_mapping => 3})
 
     assert_raises(UnsupportedFormatError) { unvalidated_format.to_validated_format }
   end
+
+  def test_speaker_mapping_no_speakers_defined
+    unvalided_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                              :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                              :channels => 3,
+                                              :sample_rate => 44100,
+                                              :byte_rate => 264600,
+                                              :block_align => 6,
+                                              :bits_per_sample => 16,
+                                              :valid_bits_per_sample => 16,
+                                              :speaker_mapping => 0 })  # According to spec, 0 means speakers
+                                                                        # are explicitly undefined for all channels
+
+    assert_equal(3, unvalided_format.channels)
+    assert_equal([:undefined, :undefined, :undefined], unvalided_format.speaker_mapping)
+  end
+
+  def test_speaker_mapping_more_speakers_defined_than_channels
+    unvalided_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                              :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                              :channels => 3,
+                                              :sample_rate => 44100,
+                                              :byte_rate => 264600,
+                                              :block_align => 6,
+                                              :bits_per_sample => 16,
+                                              :valid_bits_per_sample => 16,
+                                              :speaker_mapping => 214 })  # Bit field '11010110'
+
+    assert_equal(3, unvalided_format.channels)
+
+    # All 5 channel->speaker mappings are present, even though files only has 3 channels
+    assert_equal([:front_right, :front_center, :back_left, :front_left_of_center, :front_right_of_center], unvalided_format.speaker_mapping)
+  end
+
+  def test_speaker_mapping_more_speakers_than_are_defined
+    expected_speaker_mapping = [
+      :front_left,
+      :front_right,
+      :front_center,
+      :low_frequency,
+      :back_left,
+      :back_right,
+      :front_left_of_center,
+      :front_right_of_center,
+      :back_center,
+      :side_left,
+      :side_right,
+      :top_center,
+      :top_front_left,
+      :top_front_center,
+      :top_front_right,
+      :top_back_left,
+      :top_back_center,
+      :top_back_right,
+    ]
+
+    unvalided_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                              :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                              :channels => 3,
+                                              :sample_rate => 44100,
+                                              :byte_rate => 264600,
+                                              :block_align => 6,
+                                              :bits_per_sample => 16,
+                                              :valid_bits_per_sample => 16,
+                                              :speaker_mapping => 1048575 })  # Bit field '1111_1111_1111_1111_1111'
+
+    assert_equal(3, unvalided_format.channels)
+
+    # All channel->speaker mappings are present, even though file doesn't have this many channels
+    assert_equal(expected_speaker_mapping, unvalided_format.speaker_mapping)
+  end
+
+  def test_speaker_mapping_more_channels_than_mapped_speakers
+    unvalided_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                              :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                              :channels => 3,
+                                              :sample_rate => 44100,
+                                              :byte_rate => 264600,
+                                              :block_align => 6,
+                                              :bits_per_sample => 16,
+                                              :valid_bits_per_sample => 16,
+                                              :speaker_mapping => 2 })  # Bit field '10'
+
+    assert_equal(3, unvalided_format.channels)
+    assert_equal([:front_right, :undefined, :undefined], unvalided_format.speaker_mapping)
+  end
+
+  def test_speaker_mapping_more_channels_than_defined_speakers
+    expected_speaker_mapping = [
+      :front_left,
+      :front_right,
+      :front_center,
+      :low_frequency,
+      :back_left,
+      :back_right,
+      :front_left_of_center,
+      :front_right_of_center,
+      :back_center,
+      :side_left,
+      :side_right,
+      :top_center,
+      :top_front_left,
+      :top_front_center,
+      :top_front_right,
+      :top_back_left,
+      :top_back_center,
+      :top_back_right,
+      :undefined,   # Spec only defines first 18 speakers, any subsequent ones are undefined
+      :undefined,   # Spec only defines first 18 speakers, any subsequent ones are undefined
+    ]
+
+    unvalided_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                              :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                              :channels => 20,
+                                              :sample_rate => 44100,
+                                              :byte_rate => 1764000,
+                                              :block_align => 40,
+                                              :bits_per_sample => 16,
+                                              :valid_bits_per_sample => 16,
+                                              :speaker_mapping => 262143 })  # Bit field '11_1111_1111_1111_1111'
+
+    assert_equal(20, unvalided_format.channels)
+    assert_equal(expected_speaker_mapping, unvalided_format.speaker_mapping)
+  end
+
+  def test_speaker_mapping_more_channels_than_defined_speakers_2
+    expected_speaker_mapping = [
+      :front_left,
+      :front_right,
+      :front_center,
+      :low_frequency,
+      :back_left,
+      :back_right,
+      :front_left_of_center,
+      :front_right_of_center,
+      :back_center,
+      :side_left,
+      :side_right,
+      :top_center,
+      :top_front_left,
+      :top_front_center,
+      :top_front_right,
+      :top_back_left,
+      :top_back_center,
+      :top_back_right,
+      :undefined,
+      :undefined,
+    ]
+
+    unvalided_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                              :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                              :channels => 20,
+                                              :sample_rate => 44100,
+                                              :byte_rate => 264600,
+                                              :block_align => 6,
+                                              :bits_per_sample => 16,
+                                              :valid_bits_per_sample => 16,
+                                              :speaker_mapping => 1048575 })  # Bit field '1111_1111_1111_1111_1111'
+
+    assert_equal(20, unvalided_format.channels)
+
+    # All channel->speaker mappings are present, even though file doesn't have this many channels
+    assert_equal(expected_speaker_mapping, unvalided_format.speaker_mapping)
+  end
 end

data/test/wavefile_io_test_helper.rb

@@ -1,6 +1,11 @@
 module WaveFileIOTestHelper
   CHANNEL_ALIAS = { :mono => 1, :stereo => 2, :tri => 3}
 
+  SUPPORTED_BITS_PER_SAMPLE = {
+                                :pcm => [8, 16, 24, 32].freeze,
+                                :float => [32, 64].freeze,
+                              }.freeze
+
   SQUARE_WAVE_CYCLE = {}
   SQUARE_WAVE_CYCLE[:mono] = {}
 
@@ -9,6 +14,7 @@ module WaveFileIOTestHelper
   SQUARE_WAVE_CYCLE[:mono][:pcm_24] =   [-1000000, -1000000, -1000000, -1000000, 1000000, 1000000, 1000000, 1000000]
   SQUARE_WAVE_CYCLE[:mono][:pcm_32] =   [-1000000000, -1000000000, -1000000000, -1000000000,
                                           1000000000, 1000000000, 1000000000, 1000000000]
+  SQUARE_WAVE_CYCLE[:mono][:float] = [-0.5, -0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5]
   SQUARE_WAVE_CYCLE[:mono][:float_32] = [-0.5, -0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5]
   SQUARE_WAVE_CYCLE[:mono][:float_64] = SQUARE_WAVE_CYCLE[:mono][:float_32]
 
@@ -23,6 +29,8 @@ module WaveFileIOTestHelper
                                          [-1000000000, -1000000000], [-1000000000, -1000000000],
                                          [ 1000000000,  1000000000], [ 1000000000,  1000000000],
                                          [ 1000000000,  1000000000], [ 1000000000,  1000000000]]
+  SQUARE_WAVE_CYCLE[:stereo][:float] = [[-0.5, -0.5], [-0.5, -0.5], [-0.5, -0.5], [-0.5, -0.5],
+                                        [0.5, 0.5], [0.5, 0.5], [0.5, 0.5], [0.5, 0.5]]
   SQUARE_WAVE_CYCLE[:stereo][:float_32] = [[-0.5, -0.5], [-0.5, -0.5], [-0.5, -0.5], [-0.5, -0.5],
                                          [0.5, 0.5], [0.5, 0.5], [0.5, 0.5], [0.5, 0.5]]
   SQUARE_WAVE_CYCLE[:stereo][:float_64] = SQUARE_WAVE_CYCLE[:stereo][:float_32]
@@ -46,6 +54,8 @@ module WaveFileIOTestHelper
                                         [ 1000000000,  1000000000,  1000000000],
                                         [ 1000000000,  1000000000,  1000000000],
                                         [ 1000000000,  1000000000,  1000000000]]
+  SQUARE_WAVE_CYCLE[:tri][:float] = [[-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5],
+                                     [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]]
   SQUARE_WAVE_CYCLE[:tri][:float_32] = [[-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5],
                                         [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]]
   SQUARE_WAVE_CYCLE[:tri][:float_64] = SQUARE_WAVE_CYCLE[:tri][:float_32]
@@ -56,7 +66,7 @@ module WaveFileIOTestHelper
     ["", "extensible_"].each do |format_chunk_format|
       [:mono, :stereo, :tri].each do |channels|
         [:pcm, :float].each do |sample_format|
-          Format::SUPPORTED_BITS_PER_SAMPLE[sample_format].each do |bits_per_sample|
+          SUPPORTED_BITS_PER_SAMPLE[sample_format].each do |bits_per_sample|
             yield(format_chunk_format, channels, "#{sample_format}_#{bits_per_sample}".to_sym)
           end
         end

data/test/writer_test.rb

@@ -10,6 +10,11 @@ class WriterTest < Minitest::Test
   OUTPUT_FOLDER = "test/fixtures/actual_output"
 
   def setup
+    # Make the output folder if it doesn't already exist
+    Dir.mkdir(OUTPUT_FOLDER) unless File.exist?(OUTPUT_FOLDER)
+  end
+
+  def teardown
     clean_output_folder
   end
 
@@ -21,36 +26,115 @@ class WriterTest < Minitest::Test
   end
 
   def test_write_basic_file
-    exhaustively_test do |format_chunk_format, channels, sample_format|
-      file_name = "valid_#{channels}_#{sample_format}_44100.wav"
-      format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
+    [:mono, :stereo].each do |channels|
+      [:pcm_8, :pcm_16, :float, :float_32, :float_64].each do |sample_format|
+        file_name = "valid_#{channels}_#{sample_format === :float ? :float_32 : sample_format}_44100.wav"
+        format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
 
-      ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
-        writer = Writer.new(io_or_file_name, format)
-        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, format))
-        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, format))
-        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 24, format))
-        writer.close
+        ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+          write_file(io_or_file_name, file_name, format)
+        end
+      end
+    end
+  end
+
+  def test_write_extensible_file
+    # Otherwise non-extensible, but speaker mapping is not the default for 1 channel
+    file_name = "valid_extensible_mono_pcm_16_44100_non_default_speaker_mapping.wav"
+    format = Format.new(:mono, :pcm_16, 44100, speaker_mapping: [:front_left])
+
+    ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+      write_file(io_or_file_name, file_name, format)
+    end
+
+
+    # Otherwise non-extensible, but speaker mapping is not the default for 2 channels
+    file_name = "valid_extensible_stereo_pcm_16_44100_center_right_speakers.wav"
+    format = Format.new(:stereo, :pcm_16, 44100, speaker_mapping: [:front_right, :front_center])
+
+    ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+      write_file(io_or_file_name, file_name, format)
+    end
+
+
+    [:mono].each do |channels|
+      [:pcm_24, :pcm_32].each do |sample_format|
+        file_name = "valid_extensible_#{channels}_#{sample_format}_44100.wav"
+        format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100, speaker_mapping: [:front_center])
+
+        ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+          write_file(io_or_file_name, file_name, format)
+        end
+      end
+    end
 
-        assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+    [:stereo].each do |channels|
+      [:pcm_24, :pcm_32].each do |sample_format|
+        file_name = "valid_extensible_#{channels}_#{sample_format}_44100.wav"
+        format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100, speaker_mapping: [:front_left, :front_right])
+
+        ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+          write_file(io_or_file_name, file_name, format)
+        end
+      end
+    end
+
+    [:tri].each do |channels|
+      [:pcm_8, :pcm_16, :pcm_24, :pcm_32, :float, :float_32, :float_64].each do |sample_format|
+        file_name = "valid_extensible_#{channels}_#{sample_format === :float ? :float_32 : sample_format}_44100.wav"
+        format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100, speaker_mapping: [:front_left, :front_right, :front_center])
+
+        ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+          write_file(io_or_file_name, file_name, format)
+        end
       end
     end
   end
 
   def test_write_basic_file_with_a_block
-    exhaustively_test do |format_chunk_format, channels, sample_format|
-      file_name = "valid_#{channels}_#{sample_format}_44100.wav"
-      format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
+    [:mono, :stereo].each do |channels|
+      [:pcm_8, :pcm_16, :float, :float_32, :float_64].each do |sample_format|
+        file_name = "valid_#{channels}_#{sample_format === :float ? :float_32 : sample_format}_44100.wav"
+        format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
+
+        ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+          write_file_with_a_block(io_or_file_name, file_name, format)
+        end
+      end
+    end
+  end
+
+  def test_write_extensible_file_with_a_block
+    [:mono].each do |channels|
+      [:pcm_24, :pcm_32].each do |sample_format|
+        file_name = "valid_extensible_#{channels}_#{sample_format}_44100.wav"
+        format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100, speaker_mapping: [:front_center])
 
-      ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
-        writer = Writer.new(io_or_file_name, format) do |w|
-          4.times do
-            w.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 70, format))
-          end
+        ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+          write_file_with_a_block(io_or_file_name, file_name, format)
         end
+      end
+    end
 
-        assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
-        assert(writer.closed?)
+    [:stereo].each do |channels|
+      [:pcm_24, :pcm_32].each do |sample_format|
+        file_name = "valid_extensible_#{channels}_#{sample_format}_44100.wav"
+        format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100, speaker_mapping: [:front_left, :front_right])
+
+        ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+          write_file_with_a_block(io_or_file_name, file_name, format)
+        end
+      end
+    end
+
+    [:tri].each do |channels|
+      [:pcm_8, :pcm_16, :pcm_24, :pcm_32, :float, :float_32, :float_64].each do |sample_format|
+        file_name = "valid_extensible_#{channels}_#{sample_format === :float ? :float_32 : sample_format}_44100.wav"
+        format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100, speaker_mapping: [:front_left, :front_right, :front_center])
+
+        ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+          write_file_with_a_block(io_or_file_name, file_name, format)
+        end
       end
     end
   end
@@ -87,6 +171,75 @@ class WriterTest < Minitest::Test
     end
   end
 
+  def test_write_no_speaker_mapping
+    file_name = "valid_extensible_stereo_pcm_24_44100_no_speaker_mapping.wav"
+    format  = Format.new(:stereo, :pcm_24, 44100, speaker_mapping: [:undefined, :undefined])
+
+    ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+      write_file(io_or_file_name, file_name, format)
+    end
+  end
+
+  def test_write_incomplete_speaker_mapping
+    file_name = "valid_extensible_stereo_pcm_24_44100_incomplete_speaker_mapping.wav"
+    format  = Format.new(:stereo, :pcm_24, 44100, speaker_mapping: [:front_center])
+
+    ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+      write_file(io_or_file_name, file_name, format)
+    end
+  end
+
+  def test_write_speaker_mapping_overflow
+    speaker_mapping = [
+      :front_left,
+      :front_right,
+      :front_center,
+      :low_frequency,
+      :back_left,
+      :back_right,
+      :front_left_of_center,
+      :front_right_of_center,
+      :back_center,
+      :side_left,
+      :side_right,
+      :top_center,
+      :top_front_left,
+      :top_front_center,
+      :top_front_right,
+      :top_back_left,
+      :top_back_center,
+      :top_back_right,
+    ]
+
+    negative = [-10000] * 20
+    positive = [10000] * 20
+    square_wave_cycle = [negative, negative, negative, negative, positive, positive, positive, positive]
+
+    file_name = "valid_extensible_20_pcm_16_44100_speaker_mapping_overflow.wav"
+    format  = Format.new(20, :pcm_16, 44100, speaker_mapping: speaker_mapping)
+
+    ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+      writer = Writer.new(io_or_file_name, format)
+      writer.write(Buffer.new(square_wave_cycle * 128, format))
+      writer.write(Buffer.new(square_wave_cycle * 128, format))
+      writer.write(Buffer.new(square_wave_cycle * 24,  format))
+      writer.close
+
+      assert_equal(read_file(:expected, file_name),
+                   read_file(:actual, file_name),
+                   "Written file doesn't match expected output: #{file_name}")
+    end
+  end
+
+  def test_write_custom_speaker_mapping
+    file_name = "valid_extensible_tri_pcm_16_44100_custom_speaker_mapping.wav"
+    format  = Format.new(3, :pcm_16, 44100, speaker_mapping: [:back_left, :side_right, :top_back_left])
+
+    ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+      write_file(io_or_file_name, file_name, format)
+    end
+  end
+
   def test_close_when_constructed_from_file_name
     writer = Writer.new("#{OUTPUT_FOLDER}/closed_test.wav", Format.new(:mono, :pcm_16, 44100))
     assert_equal(false, writer.closed?)
@@ -108,7 +261,7 @@ class WriterTest < Minitest::Test
     assert(writer.closed?)
 
     assert_equal(false, io.closed?)
-    assert_equal(2092, io.pos)    # 44 bytes for header, plus 2 bytes per sample, with 8 * 128 samples 
+    assert_equal(2092, io.pos)    # 44 bytes for header, plus 2 bytes per sample, with 8 * 128 samples
     io.close
   end
 
@@ -124,6 +277,18 @@ class WriterTest < Minitest::Test
     end
   end
 
+  def test_double_close
+    format = Format.new(:mono, :pcm_8, 44100)
+
+    ["#{OUTPUT_FOLDER}/double_close.wav", StringIO.new].each do |io_or_file_name|
+      writer = Writer.new(io_or_file_name, format)
+      writer.write(Buffer.new([1, 2, 3, 4], format))
+      writer.close
+      # The test is that this doesn't raise an error
+      writer.close
+    end
+  end
+
   def test_total_duration
     exhaustively_test do |format_chunk_format, channels, sample_format|
       format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
@@ -202,7 +367,7 @@ private
 
   def read_file(type, file_name)
     if type == :expected
-      fixture_folder = 'valid'
+      fixture_folder = 'wave/valid'
     elsif type == :actual
       fixture_folder = 'actual_output'
     else
@@ -214,9 +379,6 @@ private
   end
 
   def clean_output_folder
-    # Make the folder if it doesn't already exist
-    Dir.mkdir(OUTPUT_FOLDER) unless File.exist?(OUTPUT_FOLDER)
-
     dir = Dir.new(OUTPUT_FOLDER)
     file_names = dir.entries
     file_names.each do |file_name|
@@ -225,4 +387,63 @@ private
       end
     end
   end
+
+  def write_file(io_or_file_name, file_name, format)
+    if format.channels == 1
+      channel_label = :mono
+    elsif format.channels == 2
+      channel_label = :stereo
+    elsif format.channels == 3
+      channel_label = :tri
+    end
+    sample_format = "#{format.sample_format}_#{format.bits_per_sample}".to_sym
+
+    writer = Writer.new(io_or_file_name, format)
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channel_label][sample_format] * 128, format))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channel_label][sample_format] * 128, format))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channel_label][sample_format] * 24, format))
+    writer.close
+
+    if io_or_file_name.is_a?(StringIO)
+      io_or_file_name.rewind
+      actual_file = io_or_file_name.read.force_encoding("ASCII-8BIT")
+    else
+      actual_file = read_file(:actual, file_name)
+    end
+    expected_file = read_file(:expected, file_name)
+
+    assert_equal(expected_file,
+                 actual_file,
+                 "Written file doesn't match expected output: #{file_name}")
+  end
+
+  def write_file_with_a_block(io_or_file_name, file_name, format)
+    if format.channels == 1
+      channel_label = :mono
+    elsif format.channels == 2
+      channel_label = :stereo
+    elsif format.channels == 3
+      channel_label = :tri
+    end
+    sample_format = "#{format.sample_format}_#{format.bits_per_sample}".to_sym
+
+    writer = Writer.new(io_or_file_name, format) do |w|
+      4.times do
+        w.write(Buffer.new(SQUARE_WAVE_CYCLE[channel_label][sample_format] * 70, format))
+      end
+    end
+
+    if io_or_file_name.is_a?(StringIO)
+      io_or_file_name.rewind
+      actual_file = io_or_file_name.read.force_encoding("ASCII-8BIT")
+    else
+      actual_file = read_file(:actual, file_name)
+    end
+    expected_file = read_file(:expected, file_name)
+
+    assert_equal(actual_file,
+                 expected_file,
+                 "Written file doesn't match expected output: #{file_name}")
+    assert(writer.closed?)
+  end
 end