midilib 2.0.4 → 3.1.0

data/test/test_sequence.rb

@@ -7,73 +7,74 @@ require 'test/unit'
 require 'midilib'
 
 class SequenceTester < Test::Unit::TestCase
+  def setup
+    @seq = MIDI::Sequence.new
+    @track = MIDI::Track.new(@seq)
+    @seq.tracks << @track
+    3.times { @track.events << MIDI::NoteOn.new(0, 64, 64, 100) }
+    @track.recalc_times
+  end
 
-    def setup
-	@seq = MIDI::Sequence.new
-	@track = MIDI::Track.new(@seq)
-	@seq.tracks << @track
-	3.times { @track.events << MIDI::NoteOn.new(0, 64, 64, 100) }
-	@track.recalc_times
-    end
+  def test_basics
+    assert_equal(120, @seq.beats_per_minute)
+    assert_equal(1, @seq.tracks.length)
+    assert_equal(MIDI::Track::UNNAMED, @seq.name)
+    assert_equal(MIDI::Sequence::DEFAULT_TEMPO, @seq.bpm)
+  end
 
-    def test_basics
-	assert_equal(120, @seq.beats_per_minute)
-	assert_equal(1, @seq.tracks.length)
-	assert_equal(MIDI::Track::UNNAMED, @seq.name)
-	assert_equal(MIDI::Sequence::DEFAULT_TEMPO, @seq.bpm)
-    end
+  def test_pulses_to_seconds
+    # At a tempo of 120 BPM 480 pulses (one quarter note) should take 0.5 seconds
+    assert_in_delta 0.5, @seq.pulses_to_seconds(480), 0.00001
 
-    def test_pulses_to_seconds
-      # At a tempo of 120 BPM 480 pulses (one quarter note) should take 0.5 seconds
-      assert_in_delta 0.5, @seq.pulses_to_seconds(480), 0.00001
+    # A half note should take one second
+    assert_in_delta 1.0, @seq.pulses_to_seconds(480 * 2), 0.00001
 
-      # A half note should take one second
-      assert_in_delta 1.0, @seq.pulses_to_seconds(480*2), 0.00001
+    # An eight note should take 0.25 seconds
+    assert_in_delta 0.25, @seq.pulses_to_seconds(480 / 2), 0.00001
+  end
 
-      # An eight note should take 0.25 seconds
-      assert_in_delta 0.25, @seq.pulses_to_seconds(480/2), 0.00001
-    end
+  def test_length_to_delta
+    assert_equal(480, @seq.ppqn)
+    assert_equal(480, @seq.length_to_delta(1))
+    assert_equal(240, @seq.length_to_delta(0.5))
 
-    def test_length_to_delta
-      assert_equal(480, @seq.ppqn)
-      assert_equal(480, @seq.length_to_delta(1))
-      assert_equal(240, @seq.length_to_delta(0.5))
+    @seq.ppqn = 12
+    assert_equal(12, @seq.ppqn)
+    assert_equal(12, @seq.length_to_delta(1))
+    assert_equal(6, @seq.length_to_delta(0.5))
+    # rounding tests
+    assert_equal(6, @seq.length_to_delta(0.49))
+    assert_equal(5, @seq.length_to_delta(0.45))
+  end
 
-      @seq.ppqn = 12
-      assert_equal(12, @seq.ppqn)
-      assert_equal(12, @seq.length_to_delta(1))
-      assert_equal(6, @seq.length_to_delta(0.5))
-      assert_equal(5, @seq.length_to_delta(0.49))
-    end
+  def test_note_to_length
+    assert_equal(1, @seq.note_to_length('quarter'))
+    assert_equal(4, @seq.note_to_length('whole'))
+    assert_equal(1.5, @seq.note_to_length('dotted quarter'))
+    assert_equal(1.0 / 3.0, @seq.note_to_length('quarter triplet'))
+    assert_equal(0.5, @seq.note_to_length('dotted quarter triplet'))
+    assert_equal(1.0 / 4, @seq.note_to_length('sixteenth'))
+    assert_equal(1.0 / 4, @seq.note_to_length('16th'))
+    assert_equal(1.0 / 8, @seq.note_to_length('thirty second'))
+    assert_equal(1.0 / 8, @seq.note_to_length('32nd'))
+    assert_equal(1.0 / 16, @seq.note_to_length('sixty fourth'))
+    assert_equal(1.0 / 16, @seq.note_to_length('sixtyfourth'))
+    assert_equal(1.0 / 16, @seq.note_to_length('64th'))
+  end
 
-    def test_note_to_length
-      assert_equal(1, @seq.note_to_length('quarter'))
-      assert_equal(4, @seq.note_to_length('whole'))
-      assert_equal(1.5, @seq.note_to_length('dotted quarter'))
-      assert_equal(1.0 / 3.0, @seq.note_to_length('quarter triplet'))
-      assert_equal(0.5, @seq.note_to_length('dotted quarter triplet'))
-      assert_equal(1.0 / 4, @seq.note_to_length('sixteenth'))
-      assert_equal(1.0 / 4, @seq.note_to_length('16th'))
-      assert_equal(1.0 / 8, @seq.note_to_length('thirty second'))
-      assert_equal(1.0 / 8, @seq.note_to_length('32nd'))
-      assert_equal(1.0 / 16, @seq.note_to_length('sixty fourth'))
-      assert_equal(1.0 / 16, @seq.note_to_length('sixtyfourth'))
-      assert_equal(1.0 / 16, @seq.note_to_length('64th'))
-    end
-
-    def test_note_to_delta
-      assert_equal(480, @seq.note_to_delta('quarter'))
-      assert_equal(480 * 4, @seq.note_to_delta('whole'))
-      assert_equal(720, @seq.note_to_delta('dotted quarter'))
-      assert_equal(480 / 3.0, @seq.note_to_delta('quarter triplet'))
-      assert_equal((480 / 3.0) * 1.5,
-		   @seq.note_to_delta('dotted quarter triplet'))
-      assert_equal(480 / 4, @seq.note_to_delta('sixteenth'))
-      assert_equal(480 / 4, @seq.note_to_delta('16th'))
-      assert_equal(480 / 8, @seq.note_to_delta('thirty second'))
-      assert_equal(480 / 8, @seq.note_to_delta('32nd'))
-      assert_equal(480 / 16, @seq.note_to_delta('sixty fourth'))
-      assert_equal(480 / 16, @seq.note_to_delta('sixtyfourth'))
-      assert_equal(480 / 16, @seq.note_to_delta('64th'))
-    end
+  def test_note_to_delta
+    assert_equal(480, @seq.note_to_delta('quarter'))
+    assert_equal(480 * 4, @seq.note_to_delta('whole'))
+    assert_equal(720, @seq.note_to_delta('dotted quarter'))
+    assert_equal(480 / 3.0, @seq.note_to_delta('quarter triplet'))
+    assert_equal((480 / 3.0) * 1.5,
+                 @seq.note_to_delta('dotted quarter triplet'))
+    assert_equal(480 / 4, @seq.note_to_delta('sixteenth'))
+    assert_equal(480 / 4, @seq.note_to_delta('16th'))
+    assert_equal(480 / 8, @seq.note_to_delta('thirty second'))
+    assert_equal(480 / 8, @seq.note_to_delta('32nd'))
+    assert_equal(480 / 16, @seq.note_to_delta('sixty fourth'))
+    assert_equal(480 / 16, @seq.note_to_delta('sixtyfourth'))
+    assert_equal(480 / 16, @seq.note_to_delta('64th'))
+  end
 end

data/test/test_track.rb

@@ -7,166 +7,137 @@ require 'test/unit'
 require 'midilib'
 
 class TrackTester < Test::Unit::TestCase
-
-    def setup
-	@seq = MIDI::Sequence.new
-	@track = MIDI::Track.new(@seq)
-	@seq.tracks << @track
-	3.times { @track.events << MIDI::NoteOn.new(0, 64, 64, 100) }
-	@track.recalc_times
-    end
-
-    def test_basics
-	assert_equal(3, @track.events.length)
-	3.times { | i |
-	    assert_equal(100, @track.events[i].delta_time)
-	    assert_equal((i+1) * 100, @track.events[i].time_from_start)
-	}
-	assert_equal(MIDI::Track::UNNAMED, @track.name)
-    end
-
-    def test_append_event
-	@track.events << MIDI::NoteOn.new(0, 64, 64, 100)
-	@track.recalc_times
-	assert_equal(4, @track.events.length)
-	4.times { | i |
-	    assert_equal((i+1) * 100, @track.events[i].time_from_start)
-	}
+  def setup
+    @seq = MIDI::Sequence.new
+    @track = MIDI::Track.new(@seq)
+    @seq.tracks << @track
+    3.times { @track.events << MIDI::NoteOn.new(0, 64, 64, 100) }
+    @track.recalc_times
+  end
+
+  def test_basics
+    assert_equal(3, @track.events.length)
+    3.times do |i|
+      assert_equal(100, @track.events[i].delta_time)
+      assert_equal((i + 1) * 100, @track.events[i].time_from_start)
     end
-
-    def test_append_list
-	@track.events +=
-	       (1..12).collect { | i | MIDI::NoteOn.new(0, 64, 64, 3) }
-	@track.recalc_times
-
-	3.times { | i |
-	    assert_equal(100, @track.events[i].delta_time)
-	    assert_equal((i+1) * 100, @track.events[i].time_from_start)
-	}
-	12.times { | i |
-	    assert_equal(3, @track.events[3 + i].delta_time)
-	    assert_equal(300 + ((i+1) * 3),
-			 @track.events[3 + i].time_from_start)
-	}
+    assert_equal(MIDI::Track::UNNAMED, @track.name)
+  end
+
+  def test_append_event
+    @track.events << MIDI::NoteOn.new(0, 64, 64, 100)
+    @track.recalc_times
+    assert_equal(4, @track.events.length)
+    4.times do |i|
+      assert_equal((i + 1) * 100, @track.events[i].time_from_start)
     end
+  end
 
-    def test_insert
-	@track.events[1,0] = MIDI::NoteOn.new(0, 64, 64, 3)
-	@track.recalc_times
-	assert_equal(100, @track.events[0].time_from_start)
-	assert_equal(103, @track.events[1].time_from_start)
-	assert_equal(203, @track.events[2].time_from_start)
-	assert_equal(303, @track.events[3].time_from_start)
-    end
+  def test_append_list
+    @track.events +=
+      (1..12).collect { |i| MIDI::NoteOn.new(0, 64, 64, 3) }
+    @track.recalc_times
 
-    def test_merge
-	list = (1..12).collect { | i | MIDI::NoteOn.new(0, 64, 64, 10) }
-	@track.merge(list)
-	assert_equal(15, @track.events.length)
-	assert_equal(10, @track.events[0].time_from_start)
-	assert_equal(10, @track.events[0].delta_time)
-	assert_equal(20, @track.events[1].time_from_start)
-	assert_equal(10, @track.events[1].delta_time)
-	assert_equal(30, @track.events[2].time_from_start)
-	assert_equal(40, @track.events[3].time_from_start)
-	assert_equal(50, @track.events[4].time_from_start)
-	assert_equal(60, @track.events[5].time_from_start)
-	assert_equal(70, @track.events[6].time_from_start)
-	assert_equal(80, @track.events[7].time_from_start)
-	assert_equal(90, @track.events[8].time_from_start)
-	assert_equal(100, @track.events[9].time_from_start)
-	assert_equal(100, @track.events[10].time_from_start)
-	assert_equal(110, @track.events[11].time_from_start)
-	assert_equal(120, @track.events[12].time_from_start)
-	assert_equal(200, @track.events[13].time_from_start)
-	assert_equal(300, @track.events[14].time_from_start)
+    3.times do |i|
+      assert_equal(100, @track.events[i].delta_time)
+      assert_equal((i + 1) * 100, @track.events[i].time_from_start)
     end
-
-    def test_recalc_delta_from_times
-	@track.each { | event | event.delta_time = 0 }
-	@track.recalc_delta_from_times
-	@track.each { | event | assert_equal(100, event.delta_time) }
+    12.times do |i|
+      assert_equal(3, @track.events[3 + i].delta_time)
+      assert_equal(300 + ((i + 1) * 3),
+                   @track.events[3 + i].time_from_start)
     end
-
-    def test_recalc_delta_from_times_unsorted
-      @track.events[0].time_from_start = 100
-      @track.events[1].time_from_start = 50
-      @track.events[2].time_from_start = 150
-      @track.recalc_delta_from_times
-      prev_start_time = 0
-      @track.each { | event |
-        assert(prev_start_time <= event.time_from_start)
-        assert(event.delta_time > 0)
-        prev_start_time = event.time_from_start
-      }
-    end
-
-    def test_sort
-	e = @track.events[0]
-	e.time_from_start = 300
-	e = @track.events[1]
-	e.time_from_start = 100
-	e = @track.events[2]
-	e.time_from_start = 200
-
-	@track.sort
-
-	assert_equal(100, @track.events[0].time_from_start)
-	assert_equal(100, @track.events[0].delta_time)
-
-	assert_equal(200, @track.events[1].time_from_start)
-	assert_equal(100, @track.events[1].delta_time)
-
-	assert_equal(300, @track.events[2].time_from_start)
-	assert_equal(100, @track.events[2].delta_time)
-    end
-
-    def test_quantize
-	@seq.ppqn = 80
-
-	@track.quantize(1)	# Quantize to a quarter note
-	assert_equal(80, @track.events[0].time_from_start) # was 100
-	assert_equal(240, @track.events[1].time_from_start) # was 200
-	assert_equal(320, @track.events[2].time_from_start) # was 300
-    end
-
-    def test_instrument
-	@track.instrument = 'foo'
-	assert_equal('foo', @track.instrument)
-    end
-
-    def test_old_note_class_names
-        x = MIDI::NoteOn.new(0, 64, 64, 10)
-        assert(x.kind_of?(MIDI::NoteOnEvent))  # old name
-        x = MIDI::NoteOff.new(0, 64, 64, 10)
-        assert(x.kind_of?(MIDI::NoteOffEvent)) # old name
-    end
-
-    def test_mergesort
-        @track.events = []
-
-        # Two events with later start times but earlier in the event list
-        e2 = MIDI::NoteOff.new(0, 64, 64, 100)
-        e2.time_from_start = 100
-        @track.events << e2
-
-        e3 = MIDI::NoteOn.new(0, 64, 64, 100)
-        e3.time_from_start = 100
-        @track.events << e3
-
-        # Earliest start time, latest in the list of events
-        e1 = MIDI::NoteOn.new(0, 64, 64, 100)
-        e1.time_from_start = 0
-        @track.events << e1
-
-        # Recalc sorts. Make sure note off/note on pair at t 100 are in the
-        # correct order.
-        @track.recalc_delta_from_times
-        
-        # These tests would fail before we moved to mergesort.
-        assert_equal(e1, @track.events[0])
-        assert_equal(e2, @track.events[1])
-        assert_equal(e3, @track.events[2])
-
+  end
+
+  def test_insert
+    @track.events[1, 0] = MIDI::NoteOn.new(0, 64, 64, 3)
+    @track.recalc_times
+    assert_equal(100, @track.events[0].time_from_start)
+    assert_equal(103, @track.events[1].time_from_start)
+    assert_equal(203, @track.events[2].time_from_start)
+    assert_equal(303, @track.events[3].time_from_start)
+  end
+
+  def test_merge
+    list = (1..12).collect { |i| MIDI::NoteOn.new(0, 64, 64, 10) }
+    @track.merge(list)
+    assert_equal(15, @track.events.length)
+    assert_equal(10, @track.events[0].time_from_start)
+    assert_equal(10, @track.events[0].delta_time)
+    assert_equal(20, @track.events[1].time_from_start)
+    assert_equal(10, @track.events[1].delta_time)
+    assert_equal(30, @track.events[2].time_from_start)
+    assert_equal(40, @track.events[3].time_from_start)
+    assert_equal(50, @track.events[4].time_from_start)
+    assert_equal(60, @track.events[5].time_from_start)
+    assert_equal(70, @track.events[6].time_from_start)
+    assert_equal(80, @track.events[7].time_from_start)
+    assert_equal(90, @track.events[8].time_from_start)
+    assert_equal(100, @track.events[9].time_from_start)
+    assert_equal(100, @track.events[10].time_from_start)
+    assert_equal(110, @track.events[11].time_from_start)
+    assert_equal(120, @track.events[12].time_from_start)
+    assert_equal(200, @track.events[13].time_from_start)
+    assert_equal(300, @track.events[14].time_from_start)
+  end
+
+  def test_recalc_delta_from_times
+    @track.each { |event| event.delta_time = 0 }
+    @track.recalc_delta_from_times
+    @track.each { |event| assert_equal(100, event.delta_time) }
+  end
+
+  def test_recalc_delta_from_times_unsorted
+    @track.events[0].time_from_start = 100
+    @track.events[1].time_from_start = 50
+    @track.events[2].time_from_start = 150
+    @track.recalc_delta_from_times
+    prev_start_time = 0
+    @track.each do |event|
+      assert(prev_start_time <= event.time_from_start)
+      assert(event.delta_time > 0)
+      prev_start_time = event.time_from_start
     end
+  end
+
+  def test_sort
+    e = @track.events[0]
+    e.time_from_start = 300
+    e = @track.events[1]
+    e.time_from_start = 100
+    e = @track.events[2]
+    e.time_from_start = 200
+
+    @track.sort
+
+    assert_equal(100, @track.events[0].time_from_start)
+    assert_equal(100, @track.events[0].delta_time)
+
+    assert_equal(200, @track.events[1].time_from_start)
+    assert_equal(100, @track.events[1].delta_time)
+
+    assert_equal(300, @track.events[2].time_from_start)
+    assert_equal(100, @track.events[2].delta_time)
+  end
+
+  def test_quantize
+    @seq.ppqn = 80
+
+    @track.quantize(1) # Quantize to a quarter note
+    assert_equal(80, @track.events[0].time_from_start)  # was 100
+    assert_equal(240, @track.events[1].time_from_start) # was 200
+    assert_equal(320, @track.events[2].time_from_start) # was 300
+  end
+
+  def test_instrument
+    @track.instrument = 'foo'
+    assert_equal('foo', @track.instrument)
+  end
+
+  def test_old_note_class_names
+    x = MIDI::NoteOn.new(0, 64, 64, 10)
+    assert(x.is_a?(MIDI::NoteOnEvent))  # old name
+    x = MIDI::NoteOff.new(0, 64, 64, 10)
+    assert(x.is_a?(MIDI::NoteOffEvent)) # old name
+  end
 end

data/test/test_varlen.rb

@@ -7,34 +7,30 @@ require 'test/unit'
 require 'midilib'
 
 class VarLenTester < Test::Unit::TestCase
+  VAR_LEN_TEST_DATA = {
+    0x00000000 => 0x00,
+    0x00000040 => 0x40,
+    0x0000007F => 0x7F,
+    0x00000080 => 0x8100,
+    0x00002000 => 0xC000,
+    0x00003FFF => 0xFF7F,
+    0x00004000 => 0x818000,
+    0x00100000 => 0xC08000,
+    0x001FFFFF => 0xFFFF7F,
+    0x00200000 => 0x81808000,
+    0x08000000 => 0xC0808000,
+    0x0FFFFFFF => 0xFFFFFF7F
+  }
 
-    VAR_LEN_TEST_DATA = {
-	0x00000000 => 0x00,
-	0x00000040 => 0x40,
-	0x0000007F => 0x7F,
-	0x00000080 => 0x8100,
-	0x00002000 => 0xC000,
-	0x00003FFF => 0xFF7F,
-	0x00004000 => 0x818000,
-	0x00100000 => 0xC08000,
-	0x001FFFFF => 0xFFFF7F,
-	0x00200000 => 0x81808000,
-	0x08000000 => 0xC0808000,
-	0x0FFFFFFF => 0xFFFFFF7F,
-    }
-
-    def num_to_var_len(num, answer)
-	varlen = MIDI::Utils.as_var_len(num)
-	varlen.reverse.each { | b |
-	    assert_equal(answer & 0xff, b)
-	    answer = answer >> 8
-	}
-    end
-
-    def test_num_to_var_len
-	VAR_LEN_TEST_DATA.each { | varlen, answer |
-	    num_to_var_len(varlen, answer)
-	}
+  def num_to_var_len(num, answer)
+    varlen = MIDI::Utils.as_var_len(num)
+    varlen.reverse.each do |b|
+      assert_equal(answer & 0xff, b)
+      answer = answer >> 8
     end
+  end
 
+  def test_num_to_var_len
+    VAR_LEN_TEST_DATA.each { |varlen, answer| num_to_var_len(varlen, answer) }
+  end
 end