wavefile 1.0.1 → 1.1.0

data/test/sampler_info_test.rb

@@ -0,0 +1,314 @@
+require 'minitest/autorun'
+require 'wavefile.rb'
+
+include WaveFile
+
+class SamplerInfoTest < Minitest::Test
+  VALID_32_BIT_INTEGER_TEST_VALUES = [0, 10, 4_294_967_295]
+  INVALID_32_BIT_INTEGER_TEST_VALUES = ["dsfsfsdf", :foo, -1, 4_294_967_296, 2.5, 2.0, [10], nil]
+
+  def test_missing_keywords
+    assert_raises(ArgumentError) { SamplerInfo.new }
+  end
+
+  def test_valid_manufacturer_id
+    VALID_32_BIT_INTEGER_TEST_VALUES.each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: valid_value,
+                                     product_id: 0,
+                                     sample_nanoseconds: 22675,
+                                     midi_note: 60,
+                                     fine_tuning_cents: 0.0,
+                                     smpte_format: 0,
+                                     smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                                     loops: [],
+                                     sampler_specific_data: "")
+
+      assert_equal(valid_value, sampler_info.manufacturer_id)
+    end
+  end
+
+  def test_invalid_manufacturer_id
+    INVALID_32_BIT_INTEGER_TEST_VALUES.each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: invalid_value,
+                        product_id: 0,
+                        sample_nanoseconds: 22675,
+                        midi_note: 60,
+                        fine_tuning_cents: 0.0,
+                        smpte_format: 0,
+                        smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                        loops: [],
+                        sampler_specific_data: "")
+      end
+    end
+  end
+
+  def test_valid_product_id
+    VALID_32_BIT_INTEGER_TEST_VALUES.each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: 0,
+                                     product_id: valid_value,
+                                     sample_nanoseconds: 22675,
+                                     midi_note: 60,
+                                     fine_tuning_cents: 0.0,
+                                     smpte_format: 0,
+                                     smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                                     loops: [],
+                                     sampler_specific_data: "")
+
+      assert_equal(valid_value, sampler_info.product_id)
+    end
+  end
+
+  def test_invalid_product_id
+    INVALID_32_BIT_INTEGER_TEST_VALUES.each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: 0,
+                        product_id: invalid_value,
+                        sample_nanoseconds: 22675,
+                        midi_note: 60,
+                        fine_tuning_cents: 0.0,
+                        smpte_format: 0,
+                        smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                        loops: [],
+                        sampler_specific_data: "")
+      end
+    end
+  end
+
+  def test_valid_sample_nanoseconds
+    VALID_32_BIT_INTEGER_TEST_VALUES.each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: 0,
+                                     product_id: 0,
+                                     sample_nanoseconds: valid_value,
+                                     midi_note: 60,
+                                     fine_tuning_cents: 0.0,
+                                     smpte_format: 0,
+                                     smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                                     loops: [],
+                                     sampler_specific_data: "")
+
+      assert_equal(valid_value, sampler_info.sample_nanoseconds)
+    end
+  end
+
+  def test_invalid_sample_nanoseconds
+    INVALID_32_BIT_INTEGER_TEST_VALUES.each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: 0,
+                        product_id: 0,
+                        sample_nanoseconds: invalid_value,
+                        midi_note: 60,
+                        fine_tuning_cents: 0.0,
+                        smpte_format: 0,
+                        smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                        loops: [],
+                        sampler_specific_data: "")
+      end
+    end
+  end
+
+  def test_valid_midi_note
+    VALID_32_BIT_INTEGER_TEST_VALUES.each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: 0,
+                                     product_id: 0,
+                                     sample_nanoseconds: 22675,
+                                     midi_note: valid_value,
+                                     fine_tuning_cents: 0.0,
+                                     smpte_format: 0,
+                                     smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                                     loops: [],
+                                     sampler_specific_data: "")
+
+      assert_equal(valid_value, sampler_info.midi_note)
+    end
+  end
+
+  def test_invalid_midi_note
+    INVALID_32_BIT_INTEGER_TEST_VALUES.each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: 0,
+                        product_id: 0,
+                        sample_nanoseconds: 0,
+                        midi_note: invalid_value,
+                        fine_tuning_cents: 0.0,
+                        smpte_format: 0,
+                        smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                        loops: [],
+                        sampler_specific_data: "")
+      end
+    end
+  end
+
+  def test_valid_fine_tuning_cents
+    [0, 0.0, 0.5, 50, 50.0, 50.5, 99.99999999999999, 0.0000000000000001].each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: 0,
+                                     product_id: 0,
+                                     sample_nanoseconds: 0,
+                                     midi_note: 60,
+                                     fine_tuning_cents: valid_value,
+                                     smpte_format: 0,
+                                     smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                                     loops: [],
+                                     sampler_specific_data: "")
+
+      assert_equal(valid_value, sampler_info.fine_tuning_cents)
+    end
+  end
+
+  def test_invalid_fine_tuning_cents
+    ["dsfsfsdf", :foo, -1, 4_294_967_296, nil, [50], 100, 100.0, 100.00000000001, -0.0000000000001].each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: 0,
+                        product_id: 0,
+                        sample_nanoseconds: 0,
+                        midi_note: 60,
+                        fine_tuning_cents: invalid_value,
+                        smpte_format: 0,
+                        smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                        loops: [],
+                        sampler_specific_data: "")
+      end
+    end
+  end
+
+  def test_valid_smpte_format
+    VALID_32_BIT_INTEGER_TEST_VALUES.each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: 0,
+                                     product_id: 0,
+                                     sample_nanoseconds: 22675,
+                                     midi_note: 60,
+                                     fine_tuning_cents: 0.0,
+                                     smpte_format: valid_value,
+                                     smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                                     loops: [],
+                                     sampler_specific_data: "")
+
+      assert_equal(valid_value, sampler_info.smpte_format)
+    end
+  end
+
+  def test_invalid_smpte_format
+    INVALID_32_BIT_INTEGER_TEST_VALUES.each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: 0,
+                        product_id: 0,
+                        sample_nanoseconds: 22675,
+                        midi_note: 60,
+                        fine_tuning_cents: 0.0,
+                        smpte_format: invalid_value,
+                        smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                        loops: [],
+                        sampler_specific_data: "")
+      end
+    end
+  end
+
+  def test_valid_smpte_offset
+    smpte_timecode = SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0)
+
+    [smpte_timecode].each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: 0,
+                                     product_id: 0,
+                                     sample_nanoseconds: 22675,
+                                     midi_note: 60,
+                                     fine_tuning_cents: 0.0,
+                                     smpte_format: 0,
+                                     smpte_offset: smpte_timecode,
+                                     loops: [],
+                                     sampler_specific_data: "")
+
+      assert_equal(valid_value, sampler_info.smpte_offset)
+    end
+  end
+
+  def test_invalid_smpte_offset
+    smpte_timecode = SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0)
+
+    [1, 1.5, false, ["string"], { key: :value}, [smpte_timecode = SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0), "string"]].each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: 0,
+                        product_id: 0,
+                        sample_nanoseconds: 22675,
+                        midi_note: 60,
+                        fine_tuning_cents: 0.0,
+                        smpte_format: 0,
+                        smpte_offset: invalid_value,
+                        loops: [],
+                        sampler_specific_data: "")
+      end
+    end
+  end
+
+  def test_valid_loops
+    loop1 = SamplerLoop.new(id: 0, type: :forward, start_sample_frame: 0, end_sample_frame: 0, fraction: 0.0, play_count: 1)
+    loop2 = SamplerLoop.new(id: 0, type: :forward, start_sample_frame: 0, end_sample_frame: 0, fraction: 0.0, play_count: 1)
+
+    [[], [loop1], [loop1, loop2]].each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: 0,
+                                     product_id: 0,
+                                     sample_nanoseconds: 22675,
+                                     midi_note: 60,
+                                     fine_tuning_cents: 0.0,
+                                     smpte_format: 0,
+                                     smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                                     loops: valid_value,
+                                     sampler_specific_data: "")
+
+      assert_equal(valid_value, sampler_info.loops)
+    end
+  end
+
+  def test_invalid_loops
+    loop1 = SamplerLoop.new(id: 0, type: :forward, start_sample_frame: 0, end_sample_frame: 0, fraction: 0.0, play_count: 1)
+
+    [1, 1.5, false, ["string"], { key: :value}, [loop1, "string"]].each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: 0,
+                        product_id: 0,
+                        sample_nanoseconds: 22675,
+                        midi_note: 60,
+                        fine_tuning_cents: 0.0,
+                        smpte_format: 0,
+                        smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                        loops: invalid_value,
+                        sampler_specific_data: "")
+      end
+    end
+  end
+
+  def test_valid_sampler_specific_data
+    ["", "1234"].each do |valid_value|
+      sampler_info = SamplerInfo.new(manufacturer_id: 0,
+                                     product_id: 0,
+                                     sample_nanoseconds: 22675,
+                                     midi_note: 60,
+                                     fine_tuning_cents: 0.0,
+                                     smpte_format: 0,
+                                     smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                                     loops: [],
+                                     sampler_specific_data: valid_value)
+
+      if valid_value.nil?
+        assert_nil(sampler_info.sampler_specific_data)
+      else
+        assert_equal(valid_value, sampler_info.sampler_specific_data)
+      end
+    end
+  end
+
+  def test_invalid_sampler_specific_data
+    [1, 1.5, false, ["string"], { key: :value}].each do |invalid_value|
+      assert_raises(InvalidSamplerInfoError) do
+        SamplerInfo.new(manufacturer_id: 0,
+                        product_id: 0,
+                        sample_nanoseconds: 22675,
+                        midi_note: 60,
+                        fine_tuning_cents: 0.0,
+                        smpte_format: 0,
+                        smpte_offset: SMPTETimecode.new(hours: 0, minutes: 0, seconds: 0, frames: 0),
+                        loops: [],
+                        sampler_specific_data: invalid_value)
+      end
+    end
+  end
+end

data/test/sampler_loop_test.rb

@@ -0,0 +1,215 @@
+require 'minitest/autorun'
+require 'wavefile.rb'
+
+include WaveFile
+
+class SamplerLoopTest < Minitest::Test
+  def test_missing_keywords
+    assert_raises(ArgumentError) { SamplerLoop.new }
+  end
+
+  def test_valid_id
+    [0, 10, 4_294_967_295].each do |valid_value|
+      sampler_loop = SamplerLoop.new(id: valid_value,
+                                     type: :forward,
+                                     start_sample_frame: 0,
+                                     end_sample_frame: 0,
+                                     fraction: 0.0,
+                                     play_count: 0)
+
+      assert_equal(valid_value, sampler_loop.id)
+    end
+  end
+
+  def test_invalid_id
+    ["dsfsfsdf", :foo, -1, 4_294_967_296, 2.5, 2.0, [10], nil].each do |invalid_value|
+      assert_raises(InvalidSamplerLoopError) do
+        SamplerLoop.new(id: invalid_value,
+                        type: :forward,
+                        start_sample_frame: 0,
+                        end_sample_frame: 0,
+                        fraction: 0.0,
+                        play_count: 0)
+      end
+    end
+  end
+
+  def test_valid_type
+    [:forward, :alternating, :backward].each do |valid_value|
+      sampler_loop = SamplerLoop.new(id: 0,
+                                     type: valid_value,
+                                     start_sample_frame: 0,
+                                     end_sample_frame: 0,
+                                     fraction: 0.0,
+                                     play_count: 0)
+
+      assert_equal(valid_value, sampler_loop.type)
+    end
+
+    sampler_loop = SamplerLoop.new(id: 0,
+                                   type: 0,
+                                   start_sample_frame: 0,
+                                   end_sample_frame: 0,
+                                   fraction: 0.0,
+                                   play_count: 0)
+    assert_equal(:forward, sampler_loop.type)
+
+    sampler_loop = SamplerLoop.new(id: 0,
+                                   type: 1,
+                                   start_sample_frame: 0,
+                                   end_sample_frame: 0,
+                                   fraction: 0.0,
+                                   play_count: 0)
+    assert_equal(:alternating, sampler_loop.type)
+
+    sampler_loop = SamplerLoop.new(id: 0,
+                                   type: 2,
+                                   start_sample_frame: 0,
+                                   end_sample_frame: 0,
+                                   fraction: 0.0,
+                                   play_count: 0)
+    assert_equal(:backward, sampler_loop.type)
+
+    sampler_loop = SamplerLoop.new(id: 0,
+                                   type: 3,
+                                   start_sample_frame: 0,
+                                   end_sample_frame: 0,
+                                   fraction: 0.0,
+                                   play_count: 0)
+    assert_equal(3, sampler_loop.type)
+
+    sampler_loop = SamplerLoop.new(id: 0,
+                                   type: 4_294_967_295,
+                                   start_sample_frame: 0,
+                                   end_sample_frame: 0,
+                                   fraction: 0.0,
+                                   play_count: 0)
+    assert_equal(4_294_967_295, sampler_loop.type)
+  end
+
+  def test_invalid_type
+    ["dsfsfsdf", :foo, -1, :alternatin, 4_294_967_296, 2.5, 2.0, [:forward], nil].each do |invalid_value|
+      assert_raises(InvalidSamplerLoopError) do
+        SamplerLoop.new(id: 0,
+                        type: invalid_value,
+                        start_sample_frame: 0,
+                        end_sample_frame: 0,
+                        fraction: 0.0,
+                        play_count: 0)
+      end
+    end
+  end
+
+  def test_valid_start_sample_frame
+    [0, 10, 4_294_967_295].each do |valid_value|
+      sampler_loop = SamplerLoop.new(id: 0,
+                                     type: :forward,
+                                     start_sample_frame: valid_value,
+                                     end_sample_frame: 0,
+                                     fraction: 0.0,
+                                     play_count: 0)
+
+      assert_equal(valid_value, sampler_loop.start_sample_frame)
+    end
+  end
+
+  def test_invalid_start_sample_frame
+    ["dsfsfsdf", :foo, -1, 4_294_967_296, 2.5, 2.0, [10], nil].each do |invalid_value|
+      assert_raises(InvalidSamplerLoopError) do
+        SamplerLoop.new(id: 0,
+                        type: :forward,
+                        start_sample_frame: invalid_value,
+                        end_sample_frame: 0,
+                        fraction: 0.0,
+                        play_count: 0)
+      end
+    end
+  end
+
+  def test_valid_end_sample_frame
+    [0, 10, 4_294_967_295].each do |valid_value|
+      sampler_loop = SamplerLoop.new(id: 0,
+                                     type: :forward,
+                                     start_sample_frame: 0,
+                                     end_sample_frame: valid_value,
+                                     fraction: 0.0,
+                                     play_count: 0)
+
+      assert_equal(valid_value, sampler_loop.end_sample_frame)
+    end
+  end
+
+  def test_invalid_end_sample_frame
+    ["dsfsfsdf", :foo, -1, 4_294_967_296, 2.5, 2.0, [10], nil].each do |invalid_value|
+      assert_raises(InvalidSamplerLoopError) do
+        SamplerLoop.new(id: 0,
+                        type: :forward,
+                        start_sample_frame: 0,
+                        end_sample_frame: invalid_value,
+                        fraction: 0.0,
+                        play_count: 0)
+      end
+    end
+  end
+
+  def test_valid_fraction
+    [0, 0.0, 0.5, 0.99999999999999, 0.0000000000000001].each do |valid_value|
+      sampler_loop = SamplerLoop.new(id: 0,
+                                     type: :forward,
+                                     start_sample_frame: 0,
+                                     end_sample_frame: 0,
+                                     fraction: valid_value,
+                                     play_count: 0)
+
+      assert_equal(valid_value, sampler_loop.fraction)
+    end
+  end
+
+  def test_invalid_fraction
+    ["dsfsfsdf", :foo, -1, 4_294_967_296, 2.5, 2.0, nil, [0.5], 1, 1.0, 1.00000000001, -0.0000000000001].each do |invalid_value|
+      assert_raises(InvalidSamplerLoopError) do
+        SamplerLoop.new(id: 0,
+                        type: :forward,
+                        start_sample_frame: 0,
+                        end_sample_frame: 0,
+                        fraction: invalid_value,
+                        play_count: 0)
+      end
+    end
+  end
+
+  def test_valid_play_count
+    [10, 4_294_967_295, Float::INFINITY].each do |valid_value|
+      sampler_loop = SamplerLoop.new(id: 0,
+                                     type: :forward,
+                                     start_sample_frame: 0,
+                                     end_sample_frame: 0,
+                                     fraction: 0.0,
+                                     play_count: valid_value)
+
+      assert_equal(valid_value, sampler_loop.play_count)
+    end
+
+    sampler_loop = SamplerLoop.new(id: 0,
+                                   type: :forward,
+                                   start_sample_frame: 0,
+                                   end_sample_frame: 0,
+                                   fraction: 0.0,
+                                   play_count: 0)
+
+    assert_equal(Float::INFINITY, sampler_loop.play_count)
+  end
+
+  def test_invalid_play_count
+    ["dsfsfsdf", :foo, -1, 4_294_967_296, 2.5, 2.0, [10], nil].each do |invalid_value|
+      assert_raises(InvalidSamplerLoopError) do
+        SamplerLoop.new(id: 0,
+                        type: :forward,
+                        start_sample_frame: 0,
+                        end_sample_frame: 0,
+                        fraction: 0.0,
+                        play_count: invalid_value)
+      end
+    end
+  end
+end