wavefile 0.7.0 → 0.8.0

data/test/duration_test.rb

@@ -3,7 +3,7 @@ require 'wavefile.rb'
 
 include WaveFile
 
-class DurationTest < MiniTest::Unit::TestCase
+class DurationTest < Minitest::Test
   SECONDS_IN_MINUTE = 60
   SECONDS_IN_HOUR = SECONDS_IN_MINUTE * 60
 
@@ -70,4 +70,45 @@ class DurationTest < MiniTest::Unit::TestCase
     assert_equal(samples_per_hour * 25, duration.sample_frame_count)
     assert_equal(44100, duration.sample_rate)
   end
+
+  def test_equality_exact_same_values
+    duration_1 = Duration.new(44100, 1234)
+    duration_2 = Duration.new(44100, 1234)
+
+    assert_equal(duration_1, duration_2)
+  end
+
+  def test_equality_different_values_but_same_duration
+    # Durations have different numbers of sample frames and sample rates,
+    # but both correspond to the same amount of time (1 second)
+    duration_1 = Duration.new(22050, 22050)
+    duration_2 = Duration.new(44100, 44100)
+
+    assert_equal(duration_1, duration_2)
+  end
+
+  def test_equality_different_number_of_sample_frames
+    duration_1 = Duration.new(100, 44100)
+    duration_2 = Duration.new(200, 44100)
+
+    assert_equal(false, duration_1 == duration_2)
+  end
+
+  def test_equality_different_sample_rates
+    duration_1 = Duration.new(500, 22050)
+    duration_2 = Duration.new(500, 44100)
+
+    assert_equal(false, duration_1 == duration_2)
+  end
+
+  def test_equality_less_than_millisecond_difference
+    # Although each represents a different amount of time,
+    # the difference is less than 1 millisecond, which is
+    # the maximum resolution of a Duration. Therefore, they
+    # are considered equal.
+    duration_1 = Duration.new(500, 44100)
+    duration_2 = Duration.new(501, 44100)
+
+    assert_equal(duration_1, duration_2)
+  end
 end

data/test/fixtures/unsupported/README.markdown

@@ -1,6 +1,6 @@
 The files in this folder are wave files that do not violate the wave file spec, but can not be read by the WaveFile gem.
 
 * **unsupported_audio_format.wav** - The audio format defined in the format chunk is 2, or ADPCM. While a valid format, this gem only supports 1 (PCM).
-* **unsupported_bits_per_sample.wav** - The bits per sample is 24. While this is a valid sample rate, this gem only supports 8, 16, and 32 bits per sample.
+* **unsupported_bits_per_sample.wav** - The bits per sample is 20, which is not supported by this gem.
 * **bad_channel_count.wav** - The channel count defined in the format chunk is 0.
 * **bad_sample_rate.wav** - The sample rate defined in the format chunk is 0.

data/test/format_test.rb

@@ -3,7 +3,7 @@ require 'wavefile.rb'
 
 include WaveFile
 
-class FormatTest < MiniTest::Unit::TestCase
+class FormatTest < Minitest::Test
   def test_valid_channels
     [1, 2, 3, 4, 65535].each do |valid_channels|
       assert_equal(valid_channels, Format.new(valid_channels, :pcm_16, 44100).channels)
@@ -20,10 +20,6 @@ class FormatTest < MiniTest::Unit::TestCase
   end
 
   def test_valid_sample_format
-    assert_equal(:pcm, Format.new(:mono, 8, 44100).sample_format)
-    assert_equal(:pcm, Format.new(:mono, 16, 44100).sample_format)
-    assert_equal(:pcm, Format.new(:mono, 24, 44100).sample_format)
-    assert_equal(:pcm, Format.new(:mono, 32, 44100).sample_format)
     assert_equal(:pcm, Format.new(:mono, :pcm_8, 44100).sample_format)
     assert_equal(:pcm, Format.new(:mono, :pcm_16, 44100).sample_format)
     assert_equal(:pcm, Format.new(:mono, :pcm_24, 44100).sample_format)
@@ -34,16 +30,12 @@ class FormatTest < MiniTest::Unit::TestCase
   end
 
   def test_invalid_sample_format
-    ["dsfsfsdf", :foo, 12, :pcm_14, :float_20].each do |invalid_sample_format|
+    ["dsfsfsdf", :foo, :pcm, 0, 12, :pcm_14, :pcm_abc, :float_40].each do |invalid_sample_format|
       assert_raises(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
     end
   end
 
   def test_valid_bits_per_sample
-    assert_equal(8, Format.new(:mono, 8, 44100).bits_per_sample)
-    assert_equal(16, Format.new(:mono, 16, 44100).bits_per_sample)
-    assert_equal(24, Format.new(:mono, 24, 44100).bits_per_sample)
-    assert_equal(32, Format.new(:mono, 32, 44100).bits_per_sample)
     assert_equal(8, Format.new(:mono, :pcm_8, 44100).bits_per_sample)
     assert_equal(16, Format.new(:mono, :pcm_16, 44100).bits_per_sample)
     assert_equal(24, Format.new(:mono, :pcm_24, 44100).bits_per_sample)
@@ -53,12 +45,6 @@ class FormatTest < MiniTest::Unit::TestCase
     assert_equal(64, Format.new(:mono, :float_64, 44100).bits_per_sample)
   end
 
-  def test_invalid_bits_per_sample
-    ["dsfsfsdf", :foo, :pcm, 0, 12, :pcm_14, :pcm_abc, :float_40].each do |invalid_sample_format|
-      assert_raises(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
-    end
-  end
-
   def test_valid_sample_rate
     [1, 44100, 4294967296].each do |valid_sample_rate|
       assert_equal(valid_sample_rate, Format.new(:mono, :pcm_16, valid_sample_rate).sample_rate)
@@ -73,25 +59,19 @@ class FormatTest < MiniTest::Unit::TestCase
 
   def test_byte_and_block_align
     [1, :mono].each do |one_channel|
-      [:pcm_8, 8].each do |format_code|
-        format = Format.new(one_channel, format_code, 44100)
-        assert_equal(44100, format.byte_rate)
-        assert_equal(1, format.block_align)
-      end
+      format = Format.new(one_channel, :pcm_8, 44100)
+      assert_equal(44100, format.byte_rate)
+      assert_equal(1, format.block_align)
 
-      [:pcm_16, 16].each do |format_code|
-        format = Format.new(one_channel, format_code, 44100)
-        assert_equal(88200, format.byte_rate)
-        assert_equal(2, format.block_align)
-      end
+      format = Format.new(one_channel, :pcm_16, 44100)
+      assert_equal(88200, format.byte_rate)
+      assert_equal(2, format.block_align)
 
-      [:pcm_24, 24].each do |format_code|
-        format = Format.new(one_channel, format_code, 44100)
-        assert_equal(132300, format.byte_rate)
-        assert_equal(3, format.block_align)
-      end
+      format = Format.new(one_channel, :pcm_24, 44100)
+      assert_equal(132300, format.byte_rate)
+      assert_equal(3, format.block_align)
 
-      [:pcm_32, 32, :float, :float_32].each do |format_code|
+      [:pcm_32, :float, :float_32].each do |format_code|
         format = Format.new(one_channel, format_code, 44100)
         assert_equal(176400, format.byte_rate)
         assert_equal(4, format.block_align)
@@ -103,25 +83,19 @@ class FormatTest < MiniTest::Unit::TestCase
     end
 
     [2, :stereo].each do |two_channels|
-      [:pcm_8, 8].each do |format_code|
-        format = Format.new(two_channels, format_code, 44100)
-        assert_equal(88200, format.byte_rate)
-        assert_equal(2, format.block_align)
-      end
+      format = Format.new(two_channels, :pcm_8, 44100)
+      assert_equal(88200, format.byte_rate)
+      assert_equal(2, format.block_align)
 
-      [:pcm_16, 16].each do |format_code|
-        format = Format.new(two_channels, format_code, 44100)
-        assert_equal(176400, format.byte_rate)
-        assert_equal(4, format.block_align)
-      end
+      format = Format.new(two_channels, :pcm_16, 44100)
+      assert_equal(176400, format.byte_rate)
+      assert_equal(4, format.block_align)
 
-      [:pcm_24, 24].each do |format_code|
-        format = Format.new(two_channels, format_code, 44100)
-        assert_equal(264600, format.byte_rate)
-        assert_equal(6, format.block_align)
-      end
+      format = Format.new(two_channels, :pcm_24, 44100)
+      assert_equal(264600, format.byte_rate)
+      assert_equal(6, format.block_align)
 
-      [:pcm_32, 32, :float, :float_32].each do |format_code|
+      [:pcm_32, :float, :float_32].each do |format_code|
         format = Format.new(two_channels, format_code, 44100)
         assert_equal(352800, format.byte_rate)
         assert_equal(8, format.block_align)

data/test/reader_test.rb

@@ -4,7 +4,7 @@ require 'wavefile_io_test_helper.rb'
 
 include WaveFile
 
-class ReaderTest < MiniTest::Unit::TestCase
+class ReaderTest < Minitest::Test
   include WaveFileIOTestHelper
 
   FIXTURE_ROOT_PATH = "test/fixtures"
@@ -14,7 +14,7 @@ class ReaderTest < MiniTest::Unit::TestCase
     assert_raises(Errno::ENOENT) { Reader.new(fixture("i_do_not_exist.wav")) }
   end
 
-  def test_invalid_formats
+  def test_initialize_invalid_formats
     invalid_fixtures = [
       # File contains 0 bytes
       "invalid/empty.wav",
@@ -41,14 +41,52 @@ class ReaderTest < MiniTest::Unit::TestCase
       "invalid/no_data_chunk.wav",
     ]
 
-    # Reader.new and Reader.info should raise the same errors for invalid files,
-    # so run the tests for both methods.
     invalid_fixtures.each do |fixture_name|
-      assert_raises(InvalidFormatError) { Reader.new(fixture(fixture_name)) }
+      file_name = fixture(fixture_name)
+
+      [file_name, string_io_from_file(file_name)].each do |io_or_file_name|
+        assert_raises(InvalidFormatError) { Reader.new(io_or_file_name) }
+      end
     end
   end
 
-  def test_unsupported_formats
+  def test_initialize_unsupported_format
+    file_name = fixture("unsupported/unsupported_bits_per_sample.wav")
+
+    # Unsupported format, no read format given
+    [file_name, string_io_from_file(file_name)].each do |io_or_file_name|
+      reader = Reader.new(io_or_file_name)
+      assert_equal(2, reader.native_format.channels)
+      assert_equal(20, reader.native_format.bits_per_sample)
+      assert_equal(44100, reader.native_format.sample_rate)
+      assert_equal(2, reader.format.channels)
+      assert_equal(20, reader.format.bits_per_sample)
+      assert_equal(44100, reader.format.sample_rate)
+      assert_equal(false, reader.closed?)
+      assert_equal(0, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      assert_equal(false, reader.readable_format?)
+      reader.close
+    end
+
+    # Unsupported format, different read format given
+    [file_name, string_io_from_file(file_name)].each do |io_or_file_name|
+      reader = Reader.new(io_or_file_name, Format.new(:mono, :pcm_16, 22050))
+      assert_equal(2, reader.native_format.channels)
+      assert_equal(20, reader.native_format.bits_per_sample)
+      assert_equal(44100, reader.native_format.sample_rate)
+      assert_equal(1, reader.format.channels)
+      assert_equal(16, reader.format.bits_per_sample)
+      assert_equal(22050, reader.format.sample_rate)
+      assert_equal(false, reader.closed?)
+      assert_equal(0, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      assert_equal(false, reader.readable_format?)
+      reader.close
+    end
+  end
+
+  def test_read_from_unsupported_format
     unsupported_fixtures = [
       # Audio format is 2, which is not supported
       "unsupported/unsupported_audio_format.wav",
@@ -61,105 +99,88 @@ class ReaderTest < MiniTest::Unit::TestCase
 
       # Sample rate is 0
       "unsupported/bad_sample_rate.wav",
+
+      # WAVEFORMATEXTENSIBLE, container size doesn't match sample size
+      # Although this is valid, this is not currently supported by this gem
+      "unsupported/extensible_container_size_bigger_than_sample_size.wav",
+
+      # WAVEFORMATEXTENSIBLE, the subformat GUID is not a valid format
+      # supported by this gem.
+      "unsupported/extensible_unsupported_subformat_guid.wav",
     ]
 
     unsupported_fixtures.each do |fixture_name|
-      reader = Reader.new(fixture(fixture_name))
-      assert_equal(false, reader.readable_format?)
-      assert_raises(UnsupportedFormatError) { reader.read(1024) }
-      assert_raises(UnsupportedFormatError) { reader.each_buffer(1024) {|buffer| buffer } }
-    end
-  end
+      file_name = fixture(fixture_name)
 
-  def test_initialize_unsupported_format
-    file_name = fixture("unsupported/unsupported_bits_per_sample.wav")
+      [file_name, string_io_from_file(file_name)].each do |io_or_file_name|
+        reader = Reader.new(io_or_file_name)
+        assert_equal(false, reader.readable_format?)
+        assert_raises(UnsupportedFormatError) { reader.read(1024) }
+        assert_raises(UnsupportedFormatError) { reader.each_buffer(1024) {|buffer| buffer } }
 
-    # Unsupported format, no read format given
-    reader = Reader.new(file_name)
-    assert_equal(2, reader.native_format.channels)
-    assert_equal(20, reader.native_format.bits_per_sample)
-    assert_equal(44100, reader.native_format.sample_rate)
-    assert_equal(2, reader.format.channels)
-    assert_equal(20, reader.format.bits_per_sample)
-    assert_equal(44100, reader.format.sample_rate)
-    assert_equal(false, reader.closed?)
-    assert_equal(file_name, reader.file_name)
-    assert_equal(0, reader.current_sample_frame)
-    assert_equal(2240, reader.total_sample_frames)
-    assert_equal(false, reader.readable_format?)
-    reader.close
-
-    # Unsupported format, different read format given
-    reader = Reader.new(file_name, Format.new(:mono, :pcm_16, 22050))
-    assert_equal(2, reader.native_format.channels)
-    assert_equal(20, reader.native_format.bits_per_sample)
-    assert_equal(44100, reader.native_format.sample_rate)
-    assert_equal(1, reader.format.channels)
-    assert_equal(16, reader.format.bits_per_sample)
-    assert_equal(22050, reader.format.sample_rate)
-    assert_equal(false, reader.closed?)
-    assert_equal(file_name, reader.file_name)
-    assert_equal(0, reader.current_sample_frame)
-    assert_equal(2240, reader.total_sample_frames)
-    assert_equal(false, reader.readable_format?)
-    reader.close
+        reader.close
+      end
+    end
   end
 
   def test_initialize
     format = Format.new(:stereo, :pcm_16, 22050)
 
-    exhaustively_test do |channels, sample_format|
-      file_name = fixture("valid/valid_#{channels}_#{sample_format}_44100.wav")
+    exhaustively_test do |format_chunk_format, channels, sample_format|
+      file_name = fixture("valid/valid_#{format_chunk_format}#{channels}_#{sample_format}_44100.wav")
 
       # Native format
-      reader = Reader.new(file_name)
-      assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
-      assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
-      assert_equal(44100, reader.native_format.sample_rate)
-      assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
-      assert_equal(extract_bits_per_sample(sample_format), reader.format.bits_per_sample)
-      assert_equal(44100, reader.format.sample_rate)
-      assert_equal(false, reader.closed?)
-      assert_equal(file_name, reader.file_name)
-      assert_equal(0, reader.current_sample_frame)
-      assert_equal(2240, reader.total_sample_frames)
-      assert_equal(true, reader.readable_format?)
-      reader.close
+      [file_name, string_io_from_file(file_name)].each do |io_or_file_name|
+        reader = Reader.new(io_or_file_name)
+        assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
+        assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
+        assert_equal(44100, reader.native_format.sample_rate)
+        assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
+        assert_equal(extract_bits_per_sample(sample_format), reader.format.bits_per_sample)
+        assert_equal(44100, reader.format.sample_rate)
+        assert_equal(false, reader.closed?)
+        assert_equal(0, reader.current_sample_frame)
+        assert_equal(2240, reader.total_sample_frames)
+        assert_equal(true, reader.readable_format?)
+        reader.close
+      end
 
       # Non-native format
-      reader = Reader.new(file_name, format)
-      assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
-      assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
-      assert_equal(44100, reader.native_format.sample_rate)
-      assert_equal(2, reader.format.channels)
-      assert_equal(16, reader.format.bits_per_sample)
-      assert_equal(22050, reader.format.sample_rate)
-      assert_equal(false, reader.closed?)
-      assert_equal(file_name, reader.file_name)
-      assert_equal(0, reader.current_sample_frame)
-      assert_equal(2240, reader.total_sample_frames)
-      assert_equal(true, reader.readable_format?)
-      reader.close
+      [file_name, string_io_from_file(file_name)].each do |io_or_file_name|
+        reader = Reader.new(io_or_file_name, format)
+        assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
+        assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
+        assert_equal(44100, reader.native_format.sample_rate)
+        assert_equal(2, reader.format.channels)
+        assert_equal(16, reader.format.bits_per_sample)
+        assert_equal(22050, reader.format.sample_rate)
+        assert_equal(false, reader.closed?)
+        assert_equal(0, reader.current_sample_frame)
+        assert_equal(2240, reader.total_sample_frames)
+        assert_equal(true, reader.readable_format?)
+        reader.close
+      end
 
       # Block is given.
-      reader = Reader.new(file_name) {|reader| reader.read(1024) }
-      assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
-      assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
-      assert_equal(44100, reader.native_format.sample_rate)
-      assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
-      assert_equal(extract_bits_per_sample(sample_format), reader.format.bits_per_sample)
-      assert_equal(44100, reader.format.sample_rate)
-      assert(reader.closed?)
-      assert_equal(file_name, reader.file_name)
-      assert_equal(1024, reader.current_sample_frame)
-      assert_equal(2240, reader.total_sample_frames)
-      assert_equal(true, reader.readable_format?)
+      [file_name, string_io_from_file(file_name)].each do |io_or_file_name|
+        reader = Reader.new(io_or_file_name) {|r| r.read(1024) }
+        assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
+        assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
+        assert_equal(44100, reader.native_format.sample_rate)
+        assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
+        assert_equal(extract_bits_per_sample(sample_format), reader.format.bits_per_sample)
+        assert_equal(44100, reader.format.sample_rate)
+        assert(reader.closed?)
+        assert_equal(1024, reader.current_sample_frame)
+        assert_equal(2240, reader.total_sample_frames)
+        assert_equal(true, reader.readable_format?)
+      end
     end
   end
 
   def test_read_native_format
-    exhaustively_test do |channels, sample_format|
-      buffers = read_file("valid/valid_#{channels}_#{sample_format}_44100.wav", 1024)
+    exhaustively_test do |format_chunk_format, channels, sample_format|
+      buffers = read_file("valid/valid_#{format_chunk_format}#{channels}_#{sample_format}_44100.wav", 1024)
 
       assert_equal(3, buffers.length)
       assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
@@ -169,6 +190,32 @@ class ReaderTest < MiniTest::Unit::TestCase
     end
   end
 
+  def test_read_native_extensible_format
+    channels = :stereo
+    sample_format = :pcm_16
+
+    reader = Reader.new(fixture("valid/valid_extensible_stereo_pcm_16_44100.wav"))
+    assert_equal(2, reader.native_format.channels)
+    assert_equal(16, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal(2, reader.format.channels)
+    assert_equal(16, reader.format.bits_per_sample)
+    assert_equal(44100, reader.format.sample_rate)
+    assert_equal(false, reader.closed?)
+    assert_equal(0, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+    assert_equal(true, reader.readable_format?)
+    reader.close
+
+    buffers = read_file("valid/valid_extensible_stereo_pcm_16_44100.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 24,  buffers[2].samples)
+  end
+
   def test_read_with_format_conversion
     buffers = read_file("valid/valid_mono_pcm_16_44100.wav", 1024, Format.new(:stereo, :pcm_8, 22100))
 
@@ -195,9 +242,25 @@ class ReaderTest < MiniTest::Unit::TestCase
     assert_raises(LocalJumpError) { reader.each_buffer(1024) }
   end
 
+  def test_each_buffer_no_buffer_size_given
+    exhaustively_test do |format_chunk_format, channels, sample_format|
+      reader = Reader.new(fixture("valid/valid_#{format_chunk_format}#{channels}_#{sample_format}_44100.wav"))
+
+      buffers = []
+      reader.each_buffer {|buffer| buffers << buffer }
+
+      assert(reader.closed?)
+      assert_equal(1, buffers.length)
+      assert_equal([2240], buffers.map {|buffer| buffer.samples.length })
+      assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 280, buffers[0].samples)
+      assert_equal(2240, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+    end
+  end
+
   def test_each_buffer_native_format
-    exhaustively_test do |channels, sample_format|
-      reader = Reader.new(fixture("valid/valid_#{channels}_#{sample_format}_44100.wav"))
+    exhaustively_test do |format_chunk_format, channels, sample_format|
+      reader = Reader.new(fixture("valid/valid_#{format_chunk_format}#{channels}_#{sample_format}_44100.wav"))
 
       buffers = []
       reader.each_buffer(1024) {|buffer| buffers << buffer }
@@ -270,18 +333,40 @@ class ReaderTest < MiniTest::Unit::TestCase
       # No-op
     end
     assert_equal(true, reader.closed?)
+
+    # Constructed from an File IO instance
+    io = File.open(fixture("valid/valid_mono_pcm_16_44100.wav"), "rb")
+    reader = Reader.new(io)
+    assert_equal(false, reader.closed?)
+    reader.close
+    assert(reader.closed?)
+    assert_equal(false, io.closed?)
+
+    # Constructed from an StringIO instance
+    io = StringIO.new(File.read(fixture("valid/valid_mono_pcm_16_44100.wav")))
+    reader = Reader.new(io)
+    assert_equal(false, reader.closed?)
+    reader.close
+    assert(reader.closed?)
+    assert_equal(false, io.closed?)
   end
 
   def test_read_after_close
     reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
-    buffer = reader.read(1024)
+    reader.read(1024)
+    reader.close
+    assert_raises(ReaderClosedError) { reader.read(1024) }
+
+    io = File.open(fixture("valid/valid_mono_pcm_16_44100.wav"), "rb")
+    reader = Reader.new(io)
+    reader.read(1024)
     reader.close
-    assert_raises(IOError) { reader.read(1024) }
+    assert_raises(ReaderClosedError) { reader.read(1024) }
   end
 
   def test_sample_counts_manual_reads
-    exhaustively_test do |channels, sample_format|
-      reader = Reader.new(fixture("valid/valid_#{channels}_#{sample_format}_44100.wav"))
+    exhaustively_test do |format_chunk_format, channels, sample_format|
+      reader = Reader.new(fixture("valid/valid_#{format_chunk_format}#{channels}_#{sample_format}_44100.wav"))
       
       assert_equal(0, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
@@ -319,10 +404,10 @@ class ReaderTest < MiniTest::Unit::TestCase
   end
 
   def test_sample_counts_each_buffer
-    exhaustively_test do |channels, sample_format|
+    exhaustively_test do |format_chunk_format, channels, sample_format|
       expected_results = [ 1024, 2048, 2240 ]
 
-      file_name = fixture("valid/valid_#{channels}_#{sample_format}_44100.wav")
+      file_name = fixture("valid/valid_#{format_chunk_format}#{channels}_#{sample_format}_44100.wav")
       reader = Reader.new(file_name)
 
       assert_equal(0, reader.current_sample_frame)
@@ -365,6 +450,16 @@ private
     sample_format.to_s.split("_").last.to_i
   end
 
+  def string_io_from_file(file_name)
+    file_contents = File.read(file_name)
+
+    str_io = StringIO.new
+    str_io.syswrite(file_contents)
+    str_io.rewind
+
+    str_io
+  end
+
   def test_duration(expected_hash, duration)
     assert_equal(expected_hash[:hours], duration.hours)
     assert_equal(expected_hash[:minutes], duration.minutes)