wavefile 0.4.0 → 0.5.0

data/test/writer_test.rb

@@ -10,39 +10,39 @@ class WriterTest < Test::Unit::TestCase
   OUTPUT_FOLDER = "test/fixtures/actual_output"
 
   def setup
-    clean_output_folder()
+    clean_output_folder
   end
 
   def test_write_file_with_no_sample_data
-    writer = Writer.new("#{OUTPUT_FOLDER}/no_samples.wav", Format.new(1, 8, 44100))
-    writer.close()
-    
+    writer = Writer.new("#{OUTPUT_FOLDER}/no_samples.wav", Format.new(:mono, :pcm_8, 44100))
+    writer.close
+
     assert_equal(read_file(:expected, "no_samples.wav"), read_file(:actual, "no_samples.wav"))
   end
 
   def test_write_basic_file
-    exhaustively_test do |channels, bits_per_sample|
-      file_name = "valid_#{channels}_#{bits_per_sample}_44100.wav"
-      format = Format.new(CHANNEL_ALIAS[channels], bits_per_sample, 44100)
+    exhaustively_test do |channels, sample_format|
+      file_name = "valid_#{channels}_#{sample_format}_44100.wav"
+      format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
 
       writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format)
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, format))
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, format))
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 24, format))
-      writer.close()
+      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
 
       assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
     end
   end
 
   def test_write_basic_file_with_a_block
-    exhaustively_test do |channels, bits_per_sample|
-      file_name = "valid_#{channels}_#{bits_per_sample}_44100.wav"
-      format = Format.new(CHANNEL_ALIAS[channels], bits_per_sample, 44100)
+    exhaustively_test do |channels, sample_format|
+      file_name = "valid_#{channels}_#{sample_format}_44100.wav"
+      format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
 
       writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format) do |writer|
         4.times do
-          writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 70, format))
+          writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 70, format))
         end
       end
 
@@ -52,58 +52,145 @@ class WriterTest < Test::Unit::TestCase
   end
 
   def test_write_buffers_of_different_formats
-    file_name = "valid_mono_8_44100.wav"
-    format_8bit_mono    = Format.new(:mono,   8,  44100)
-    format_16_bit_mono  = Format.new(:mono,   16, 22050)
-    format_16bit_stereo = Format.new(:stereo, 16, 44100)
+    file_name = "valid_mono_pcm_8_44100.wav"
+    format_8bit_mono    = Format.new(:mono,   :pcm_8,  44100)
+    format_16_bit_mono  = Format.new(:mono,   :pcm_16, 22050)
+    format_16bit_stereo = Format.new(:stereo, :pcm_16, 44100)
 
     writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format_8bit_mono)
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][16] * 128, format_16bit_stereo))
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][16] * 128,   format_16_bit_mono))
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][16] * 24,  format_16bit_stereo))
-    writer.close()
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, format_16bit_stereo))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128,   format_16_bit_mono))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 24,  format_16bit_stereo))
+    writer.close
 
     assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
   end
 
   def test_write_file_with_padding_byte
-    file_name = "valid_mono_8_44100_with_padding_byte.wav"
-    format = Format.new(1, 8, 44100)
+    file_name = "valid_mono_pcm_8_44100_with_padding_byte.wav"
+    format = Format.new(:mono, :pcm_8, 44100)
 
     writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format)
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][8] * 128, format))
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][8] * 128, format))
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][8] * 23 + [88, 88, 88, 88, 167, 167, 167], format))
-    writer.close()
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, format))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, format))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 23 + [88, 88, 88, 88, 167, 167, 167], format))
+    writer.close
 
     assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
   end
-  
+
+  def test_file_name
+    file_name = "#{OUTPUT_FOLDER}/example.wav"
+
+    writer = Writer.new(file_name, Format.new(:mono, :pcm_8, 44100))
+    assert_equal("#{OUTPUT_FOLDER}/example.wav", writer.file_name)
+
+    writer.close
+    assert_equal("#{OUTPUT_FOLDER}/example.wav", writer.file_name)
+  end
+
   def test_closed?
-    writer = Writer.new("#{OUTPUT_FOLDER}/closed_test.wav", Format.new(1, 16, 44100))
+    writer = Writer.new("#{OUTPUT_FOLDER}/closed_test.wav", Format.new(:mono, :pcm_16, 44100))
     assert_equal(false, writer.closed?)
-    writer.close()
+    writer.close
     assert(writer.closed?)
   end
 
   def test_attempt_to_write_after_close
-    format = Format.new(1, 8, 44100)
+    format = Format.new(:mono, :pcm_8, 44100)
 
     writer = Writer.new("#{OUTPUT_FOLDER}/write_after_close.wav", format)
     writer.write(Buffer.new([1, 2, 3, 4], format))
-    writer.close()
+    writer.close
 
     assert_raise(IOError) { writer.write(Buffer.new([5, 6, 7, 8], format)) }
   end
 
+  def test_total_duration
+    exhaustively_test do |channels, sample_format|
+      format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
+
+      writer = Writer.new("#{OUTPUT_FOLDER}/total_duration_#{channels}_#{sample_format}_44100.wav", format)
+
+      assert_equal(0, writer.total_sample_frames)
+      duration = writer.total_duration
+      assert_equal(0, duration.sample_frame_count)
+      assert_equal(44100, duration.sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(0, duration.minutes)
+      assert_equal(0, duration.seconds)
+      assert_equal(0, duration.milliseconds)
+
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
+
+      assert_equal(8 * 2756, writer.total_sample_frames)
+      duration = writer.total_duration
+      assert_equal(8 * 2756, duration.sample_frame_count)
+      assert_equal(44100, duration.sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(0, duration.minutes)
+      assert_equal(0, duration.seconds)
+      assert_equal(499, duration.milliseconds)
+
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
+
+      assert_equal(8 * 2756 * 3, writer.total_sample_frames)
+      duration = writer.total_duration
+      assert_equal(8 * 2756 * 3, duration.sample_frame_count)
+      assert_equal(44100, duration.sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(0, duration.minutes)
+      assert_equal(1, duration.seconds)
+      assert_equal(499, duration.milliseconds)
+
+      writer.close
+
+      assert_equal(8 * 2756 * 3, writer.total_sample_frames)
+      duration = writer.total_duration
+      assert_equal(8 * 2756 * 3, duration.sample_frame_count)
+      assert_equal(44100, duration.sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(0, duration.minutes)
+      assert_equal(1, duration.seconds)
+      assert_equal(499, duration.milliseconds)
+    end
+  end
+
+  # Cause an exception within the block passed to Writer.new, to prove
+  # that close is still called (due to an ensure statement in Writer.new).
+  def test_exception_with_block
+    format = Format.new(:mono, :pcm_8, 44100)
+    samples = [1, 2, 3, 4, 5, 6]
+    Writer.new("#{OUTPUT_FOLDER}/exception_with_block.wav", format) do |writer|
+      begin
+        writer.write(Buffer.new(samples, format))
+        1 / 0 # cause divide-by-zero exception
+      rescue
+        # catch the exception and ignore, so test passes OK
+      end
+    end
+    
+    reader = Reader.new("#{OUTPUT_FOLDER}/exception_with_block.wav")
+    assert_equal(samples.size, reader.total_sample_frames)
+  end
+
 private
 
   def read_file(type, file_name)
-    # For Windows compatibility with binary files, File.read() is not directly used
-    return File.open("test/fixtures/#{type}_output/#{file_name}", "rb") {|f| f.read() }
+    if type == :expected
+      fixture_folder = 'valid'
+    elsif type == :actual
+      fixture_folder = 'actual_output'
+    else
+      raise 'Invalid fixture type'
+    end
+
+    # For Windows compatibility with binary files, File.read is not directly used
+    File.open("test/fixtures/#{fixture_folder}/#{file_name}", "rb") {|f| f.read }
   end
 
-  def clean_output_folder()
+  def clean_output_folder
     # Make the folder if it doesn't already exist
     Dir.mkdir(OUTPUT_FOLDER) unless File.exists?(OUTPUT_FOLDER)
 

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: wavefile
 version: !ruby/object:Gem::Version
-  version: 0.4.0
-  prerelease: 
+  version: 0.5.0
 platform: ruby
 authors:
 - Joel Strait
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-01 00:00:00.000000000 Z
+date: 2013-02-25 00:00:00.000000000 Z
 dependencies: []
-description: 
+description: You can use this gem to create Ruby programs that produce audio. Since
+  it is written in pure Ruby (as opposed to wrapping an existing C library), you can
+  use it without having to compile a separate extension.
 email: joel dot strait at Google's popular web mail service
 executables: []
 extensions: []
@@ -21,24 +22,15 @@ files:
 - README.markdown
 - Rakefile
 - lib/wavefile/buffer.rb
+- lib/wavefile/duration.rb
 - lib/wavefile/format.rb
 - lib/wavefile/info.rb
 - lib/wavefile/reader.rb
 - lib/wavefile/writer.rb
 - lib/wavefile.rb
 - test/buffer_test.rb
-- test/fixtures/actual_output/valid_mono_8_44100_with_padding_byte.wav
-- test/fixtures/expected_output/no_samples.wav
-- test/fixtures/expected_output/valid_mono_16_44100.wav
-- test/fixtures/expected_output/valid_mono_32_44100.wav
-- test/fixtures/expected_output/valid_mono_8_44100.wav
-- test/fixtures/expected_output/valid_mono_8_44100_with_padding_byte.wav
-- test/fixtures/expected_output/valid_stereo_16_44100.wav
-- test/fixtures/expected_output/valid_stereo_32_44100.wav
-- test/fixtures/expected_output/valid_stereo_8_44100.wav
-- test/fixtures/expected_output/valid_tri_16_44100.wav
-- test/fixtures/expected_output/valid_tri_32_44100.wav
-- test/fixtures/expected_output/valid_tri_8_44100.wav
+- test/duration_test.rb
+- test/fixtures/actual_output/valid_mono_pcm_8_44100_with_padding_byte.wav
 - test/fixtures/invalid/bad_riff_header.wav
 - test/fixtures/invalid/bad_wavefile_format.wav
 - test/fixtures/invalid/empty.wav
@@ -54,17 +46,24 @@ files:
 - test/fixtures/unsupported/README.markdown
 - test/fixtures/unsupported/unsupported_audio_format.wav
 - test/fixtures/unsupported/unsupported_bits_per_sample.wav
+- test/fixtures/valid/no_samples.wav
 - test/fixtures/valid/README.markdown
-- test/fixtures/valid/valid_mono_16_44100.wav
-- test/fixtures/valid/valid_mono_32_44100.wav
-- test/fixtures/valid/valid_mono_8_44100.wav
-- test/fixtures/valid/valid_mono_8_44100_with_padding_byte.wav
-- test/fixtures/valid/valid_stereo_16_44100.wav
-- test/fixtures/valid/valid_stereo_32_44100.wav
-- test/fixtures/valid/valid_stereo_8_44100.wav
-- test/fixtures/valid/valid_tri_16_44100.wav
-- test/fixtures/valid/valid_tri_32_44100.wav
-- test/fixtures/valid/valid_tri_8_44100.wav
+- test/fixtures/valid/valid_mono_float_32_44100.wav
+- test/fixtures/valid/valid_mono_float_64_44100.wav
+- test/fixtures/valid/valid_mono_pcm_16_44100.wav
+- test/fixtures/valid/valid_mono_pcm_32_44100.wav
+- test/fixtures/valid/valid_mono_pcm_8_44100.wav
+- test/fixtures/valid/valid_mono_pcm_8_44100_with_padding_byte.wav
+- test/fixtures/valid/valid_stereo_float_32_44100.wav
+- test/fixtures/valid/valid_stereo_float_64_44100.wav
+- test/fixtures/valid/valid_stereo_pcm_16_44100.wav
+- test/fixtures/valid/valid_stereo_pcm_32_44100.wav
+- test/fixtures/valid/valid_stereo_pcm_8_44100.wav
+- test/fixtures/valid/valid_tri_float_32_44100.wav
+- test/fixtures/valid/valid_tri_float_64_44100.wav
+- test/fixtures/valid/valid_tri_pcm_16_44100.wav
+- test/fixtures/valid/valid_tri_pcm_32_44100.wav
+- test/fixtures/valid/valid_tri_pcm_8_44100.wav
 - test/format_test.rb
 - test/info_test.rb
 - test/reader_test.rb
@@ -72,26 +71,25 @@ files:
 - test/writer_test.rb
 homepage: http://www.joelstrait.com/
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
-summary: A class for reading and writing Wave sound files (*.wav)
+specification_version: 4
+summary: A pure Ruby library for reading and writing Wave sound files (*.wav)
 test_files: []