midilib 2.0.2 → 3.0.1

data/test/event_equality.rb

@@ -5,77 +5,75 @@
 # classes. If someone disagrees, it would be trivial to move them there.
 
 module MIDI
-
-    class Event
-	def ==(an_obj)
-	    return an_obj.instance_of?(self.class) &&
-		@status == an_obj.status &&
-		@delta_time == an_obj.delta_time &&
-		@time_from_start == an_obj.time_from_start
-	end
+  class Event
+    def ==(other)
+      other.instance_of?(self.class) &&
+        @status == other.status &&
+        @delta_time == other.delta_time &&
+        @time_from_start == other.time_from_start
     end
+  end
 
-    class ChannelEvent
-	def ==(an_obj)
-	    return super(an_obj) && @channel == an_obj.channel
-	end
+  class ChannelEvent
+    def ==(other)
+      super(other) && @channel == other.channel
     end
+  end
 
-    class NoteEvent < ChannelEvent
-	def ==(an_obj)
-	    return super(an_obj) &&
-		@note == an_obj.note && @velocity == an_obj.velocity
-	end
+  class NoteEvent < ChannelEvent
+    def ==(other)
+      super(other) &&
+        @note == other.note && @velocity == other.velocity
     end
+  end
 
-    class Controller < ChannelEvent
-	def ==(an_obj)
-	    return super(an_obj) &&
-		@controller == an_obj.controller && @value == an_obj.value
-	end
+  class Controller < ChannelEvent
+    def ==(other)
+      super(other) &&
+        @controller == other.controller && @value == other.value
     end
+  end
 
-    class ProgramChange < ChannelEvent
-	def ==(an_obj)
-	    return super(an_obj) && @program == an_obj.program
-	end
+  class ProgramChange < ChannelEvent
+    def ==(other)
+      super(other) && @program == other.program
     end
+  end
 
-    class ChannelPressure < ChannelEvent
-	def ==(an_obj)
-	    return super(an_obj) && @pressure == an_obj.pressure
-	end
+  class ChannelPressure < ChannelEvent
+    def ==(other)
+      super(other) && @pressure == other.pressure
     end
+  end
 
-    class PitchBend < ChannelEvent
-	def ==(an_obj)
-	    return super(an_obj) && @value == an_obj.value
-	end
+  class PitchBend < ChannelEvent
+    def ==(other)
+      super(other) && @value == other.value
     end
+  end
 
-    class SystemExclusive < SystemCommon
-	def ==(an_obj)
-	    return super(an_obj) && @data == an_obj.data
-	end
+  class SystemExclusive < SystemCommon
+    def ==(other)
+      super(other) && @data == other.data
     end
+  end
 
-    class SongPointer < SystemCommon
-	def ==(an_obj)
-	    return super(an_obj) && @pointer == an_obj.pointer
-	end
+  class SongPointer < SystemCommon
+    def ==(other)
+      super(other) && @pointer == other.pointer
     end
+  end
 
-    class SongSelect < SystemCommon
-	def ==(an_obj)
-	    return super(an_obj) && @song == an_obj.song
-	end
+  class SongSelect < SystemCommon
+    def ==(other)
+      super(other) && @song == other.song
     end
+  end
 
-    class MetaEvent < Event
-	def ==(an_obj)
-	    return super(an_obj) && @meta_type == an_obj.meta_type &&
-		@data == an_obj.data
-	end
+  class MetaEvent < Event
+    def ==(other)
+      super(other) && @meta_type == other.meta_type &&
+        @data == other.data
     end
-
+  end
 end

data/test/test_event.rb

@@ -7,131 +7,127 @@ require 'test/unit'
 require 'midilib'
 
 class EventTester < Test::Unit::TestCase
-
-    def test_note_on
-	e = MIDI::NoteOn.new
-	assert_equal(MIDI::NOTE_ON, e.status)
-	assert_equal(0, e.channel)
-	assert_equal(64, e.note)
-	assert_equal(64, e.velocity)
-	assert_equal(0, e.delta_time)
-	assert_equal(0, e.time_from_start)
-    end
-
-    def test_quantize
-	e = MIDI::NoteOn.new
-	e.quantize_to(4)
-	assert_equal(0, e.time_from_start)
-
-	# Each value in this array is the expected quantized value of
-	# its index in the array.
-
-	# Test with quantize_to(4)
-	[0, 0, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 12, 12, 16].each_with_index {
-	    | after, before |
-	    e.time_from_start = before
-	    e.quantize_to(4)
-	    assert_equal(after, e.time_from_start)
-	}
-
-	# Test with quantize_to(6)
-	[0, 0, 0, 6, 6, 6, 6, 6, 6, 12, 12, 12, 12, 12, 12,
-	 18, 18, 18, 18, 18, 18, 24].each_with_index {
-	    | after, before |
-	    e.time_from_start = before
-	    e.quantize_to(6)
-	    assert_equal(after, e.time_from_start)
-	}
-    end
-
-    def test_to_s
-	e = MIDI::NoteOn.new
-	assert_equal("0: ch 00 on 40 40", e.to_s)
-	e.print_decimal_numbers = true
-	assert_equal("0: ch 0 on 64 64", e.to_s)
-	e.print_note_names = true
-	assert_equal("0: ch 0 on E4 64", e.to_s)
-	e.print_decimal_numbers = false
-	assert_equal("0: ch 00 on E4 40", e.to_s)
-    end
-
-    def test_pitch_bend
-      e = MIDI::PitchBend.new(0, 128)
-      b = e.data_as_bytes
-      assert_equal(0, b[1])	# lsb, 7 bits
-      assert_equal(1, b[2])	# msb, 7 bits
-
-      e.value = (3 << 7) + 42
-      b = e.data_as_bytes
-      assert_equal(42, b[1])	# lsb, 7 bits
-      assert_equal(3, b[2])	# msb, 7 bits
-    end
-
-    def test_quantize
-	e = MIDI::NoteOn.new(0, 64, 64, 0)
-	e.quantize_to(80)
-	assert_equal(0, e.time_from_start)
-
-	e.time_from_start = 1
-	e.quantize_to(80)
-	assert_equal(0, e.time_from_start)
-
-	e.time_from_start = 70
-	e.quantize_to(80)
-	assert_equal(80, e.time_from_start)
-
-	e.time_from_start = 100
-	e.quantize_to(80)
-	assert_equal(80, e.time_from_start)
-
-	e.time_from_start = 398
-	e.quantize_to(80)
-	assert_equal(400, e.time_from_start)
-
-	e.time_from_start = 405
-	e.quantize_to(80)
-	assert_equal(400, e.time_from_start)
-
-	e.time_from_start = 439
-	e.quantize_to(80)
-	assert_equal(400, e.time_from_start)
-
-	e.time_from_start = 440
-	e.quantize_to(80)
-	assert_equal(480, e.time_from_start)
-
-	e.time_from_start = 441
-	e.quantize_to(80)
-	assert_equal(480, e.time_from_start)
+  def test_note_on
+    e = MIDI::NoteOn.new
+    assert_equal(MIDI::NOTE_ON, e.status)
+    assert_equal(0, e.channel)
+    assert_equal(64, e.note)
+    assert_equal(64, e.velocity)
+    assert_equal(0, e.delta_time)
+    assert_equal(0, e.time_from_start)
+  end
+
+  def test_to_s
+    e = MIDI::NoteOn.new
+    assert_equal('0: ch 00 on 40 40', e.to_s)
+    e.print_decimal_numbers = true
+    assert_equal('0: ch 0 on 64 64', e.to_s)
+    e.print_note_names = true
+    assert_equal('0: ch 0 on E4 64', e.to_s)
+    e.print_decimal_numbers = false
+    assert_equal('0: ch 00 on E4 40', e.to_s)
+  end
+
+  def test_pitch_bend
+    e = MIDI::PitchBend.new(0, 128)
+    b = e.data_as_bytes
+    assert_equal(0, b[1])       # lsb, 7 bits
+    assert_equal(1, b[2])       # msb, 7 bits
+
+    e.value = (3 << 7) + 42
+    b = e.data_as_bytes
+    assert_equal(42, b[1])      # lsb, 7 bits
+    assert_equal(3, b[2])       # msb, 7 bits
+  end
+
+  def test_quantize_1
+    e = MIDI::NoteOn.new
+    e.quantize_to(4)
+    assert_equal(0, e.time_from_start)
+
+    # Each value in this array is the expected quantized value of
+    # its index in the array.
+
+    # Test with quantize_to(4)
+    [0, 0, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 12, 12, 16].each_with_index do |after, before|
+      e.time_from_start = before
+      e.quantize_to(4)
+      assert_equal(after, e.time_from_start)
     end
 
-    def test_meta_strings
-	e = MIDI::MetaEvent.new(MIDI::META_TEXT, [97, 98, 99])
-	assert_equal([97, 98, 99], e.data)
-	assert_equal('abc', e.data_as_str)
-
-        assert_equal([MIDI::META_EVENT, MIDI::META_TEXT, 3, 97, 98, 99], e.data_as_bytes)
+    # Test with quantize_to(6)
+    [0, 0, 0, 6, 6, 6, 6, 6, 6, 12, 12, 12, 12, 12, 12,
+     18, 18, 18, 18, 18, 18, 24].each_with_index do |after, before|
+      e.time_from_start = before
+      e.quantize_to(6)
+      assert_equal(after, e.time_from_start)
     end
-
-    def test_meta_event_string_in_ctor
-	e = MIDI::MetaEvent.new(MIDI::META_TEXT, 'abc')
-	assert_equal([97, 98, 99], e.data)
-	assert_equal('abc', e.data_as_str)
-        assert_equal([MIDI::META_EVENT, MIDI::META_TEXT, 3, 97, 98, 99], e.data_as_bytes)
-    end
-
-    def test_meta_event_data_assignment
-	foobar_as_array = [102, 111, 111, 98, 97, 114]
-
-	e = MIDI::MetaEvent.new(MIDI::META_TEXT, [97, 98, 99])
-	e.data = 'foobar'
-	assert_equal('foobar', e.data_as_str)
-	assert_equal(foobar_as_array, e.data)
-
-	e.data = nil
-	e.data = foobar_as_array
-	assert_equal('foobar', e.data_as_str)
-	assert_equal(foobar_as_array, e.data)
-    end
-
+  end
+
+  def test_quantize_2
+    e = MIDI::NoteOn.new(0, 64, 64, 0)
+    e.quantize_to(80)
+    assert_equal(0, e.time_from_start)
+
+    e.time_from_start = 1
+    e.quantize_to(80)
+    assert_equal(0, e.time_from_start)
+
+    e.time_from_start = 70
+    e.quantize_to(80)
+    assert_equal(80, e.time_from_start)
+
+    e.time_from_start = 100
+    e.quantize_to(80)
+    assert_equal(80, e.time_from_start)
+
+    e.time_from_start = 398
+    e.quantize_to(80)
+    assert_equal(400, e.time_from_start)
+
+    e.time_from_start = 405
+    e.quantize_to(80)
+    assert_equal(400, e.time_from_start)
+
+    e.time_from_start = 439
+    e.quantize_to(80)
+    assert_equal(400, e.time_from_start)
+
+    e.time_from_start = 440
+    e.quantize_to(80)
+    assert_equal(480, e.time_from_start)
+
+    e.time_from_start = 441
+    e.quantize_to(80)
+    assert_equal(480, e.time_from_start)
+  end
+
+  def test_meta_strings
+    e = MIDI::MetaEvent.new(MIDI::META_TEXT, [97, 98, 99])
+    assert_equal([97, 98, 99], e.data)
+    assert_equal('abc', e.data_as_str)
+
+    assert_equal([MIDI::META_EVENT, MIDI::META_TEXT, 3, 97, 98, 99], e.data_as_bytes)
+  end
+
+  def test_meta_event_string_in_ctor
+    e = MIDI::MetaEvent.new(MIDI::META_TEXT, 'abc')
+    assert_equal([97, 98, 99], e.data)
+    assert_equal('abc', e.data_as_str)
+    assert_equal([MIDI::META_EVENT, MIDI::META_TEXT, 3, 97, 98, 99], e.data_as_bytes)
+  end
+
+  def test_meta_event_data_assignment
+    foobar_as_array = [102, 111, 111, 98, 97, 114]
+
+    e = MIDI::MetaEvent.new(MIDI::META_TEXT, [97, 98, 99])
+    e.data = 'foobar'
+    assert_equal('foobar', e.data_as_str)
+    assert_equal(foobar_as_array, e.data)
+
+    e.data = nil
+    e.data = foobar_as_array
+    assert_equal('foobar', e.data_as_str)
+    assert_equal(foobar_as_array, e.data)
+  end
 end

data/test/test_io.rb

@@ -7,57 +7,124 @@ $LOAD_PATH[0, 0] = File.dirname(__FILE__)
 
 require 'test/unit'
 require 'midilib'
+require 'midilib/consts'
 require 'event_equality'
 
 class IOTester < Test::Unit::TestCase
+  SEQ_TEST_FILE = File.join(File.dirname(__FILE__), 'test.mid')
+  OUTPUT_FILE = 'testout.mid'
+  TEMPFILE = '/tmp/midilib_test.mid'
 
-    SEQ_TEST_FILE = File.join(File.dirname(__FILE__), 'test.mid')
-    OUTPUT_FILE = 'testout.mid'
-
-    def compare_tracks(t0, t1)
-	assert_equal(t0.name, t1.name, 'track names differ')
-	assert_equal(t0.events.length, t1.events.length,
-		     'number of track events differ')
-	t0.each_with_index { | ev0, i |
-	    assert_equal(ev0, t1.events[i], 'events differ')
-	}
-	assert_equal(t0.instrument, t1.instrument)
-    end
-
-    def compare_sequences(s0, s1)
-	assert_equal(s0.name, s1.name, 'sequence names differ')
-	assert_equal(s0.tracks.length, s1.tracks.length,
-		     'number of tracks differ')
-	s0.each_with_index { | track0, i |
-	    compare_tracks(track0, s1.tracks[i])
-	}
-    end
+  def compare_tracks(t0, t1)
+    assert_equal(t0.name, t1.name, 'track names differ')
+    assert_equal(t0.events.length, t1.events.length,
+                 'number of track events differ')
+    t0.each_with_index { |ev0, i| assert_equal(ev0, t1.events[i], 'events differ') }
+    assert_equal(t0.instrument, t1.instrument)
+  end
 
-    def test_read_and_write
-	seq0 = MIDI::Sequence.new()
+  def compare_sequences(s0, s1)
+    assert_equal(s0.name, s1.name, 'sequence names differ')
+    assert_equal(s0.tracks.length, s1.tracks.length,
+                 'number of tracks differ')
+    s0.each_with_index { |track0, i| compare_tracks(track0, s1.tracks[i]) }
+  end
 
-	puts if $DEBUG
-	puts '    reading file' if $DEBUG
-	File.open(SEQ_TEST_FILE, 'rb') { | f | seq0.read(f) }
+  def compare_sequences_format_0(multitrack_seq, format0_seq)
+    assert_equal(multitrack_seq.name, format0_seq.name, 'sequence names differ')
+    assert_equal(1, format0_seq.tracks.length, 'number of tracks differ')
+    format_1_count = multitrack_seq.tracks.map { |t| t.events.count }.reduce(:+)
+    format_0_count = format0_seq.tracks.map { |t| t.events.count }.reduce(:+)
+    assert_equal(format_1_count, format_0_count, 'same number of total events')
+  end
 
-	puts '    writing file' if $DEBUG
-	File.open(OUTPUT_FILE, 'wb') { | f | seq0.write(f) }
+  def test_read_and_write
+    seq0 = MIDI::Sequence.new
+    File.open(SEQ_TEST_FILE, 'rb') { |f| seq0.read(f) }
+    File.open(OUTPUT_FILE, 'wb') { |f| seq0.write(f) }
+    seq1 = MIDI::Sequence.new
+    File.open(OUTPUT_FILE, 'rb') { |f| seq1.read(f) }
+    compare_sequences(seq0, seq1)
+  ensure
+    File.delete(OUTPUT_FILE) if File.exist?(OUTPUT_FILE)
+  end
 
-	puts '    reading file' if $DEBUG
-	seq1 = MIDI::Sequence.new()
-	File.open(OUTPUT_FILE, 'rb') { | f | seq1.read(f) }
+  def test_read_and_write_format_0
+    seq0 = MIDI::Sequence.new
+    File.open(SEQ_TEST_FILE, 'rb') { |f| seq0.read(f) }
+    File.open(OUTPUT_FILE, 'wb') { |f| seq0.write(f, 0) }
+    seq1 = MIDI::Sequence.new
+    File.open(OUTPUT_FILE, 'rb') { |f| seq1.read(f) }
+    compare_sequences_format_0(seq0, seq1)
+  ensure
+    File.delete(OUTPUT_FILE) if File.exist?(OUTPUT_FILE)
+  end
 
-	puts '    comparing sequences' if $DEBUG
-	compare_sequences(seq0, seq1)
-      ensure
-	File.delete(OUTPUT_FILE) if File.exist?(OUTPUT_FILE)
+  def test_read_callback
+    seq = MIDI::Sequence.new
+    names = []
+    num_tracks = -1
+    File.open(SEQ_TEST_FILE, 'rb') do |f|
+      seq.read(f) do |track, ntracks, i|
+        names << (track ? track.name : nil)
+        num_tracks = ntracks
+      end
     end
+    assert_equal(names, [nil, 'Sequence Name', 'My New Track'])
+    assert_equal(num_tracks, 2)
+  ensure
+    File.delete(OUTPUT_FILE) if File.exist?(OUTPUT_FILE)
+  end
+
+  def test_write_callback
+    seq = MIDI::Sequence.new
+    File.open(SEQ_TEST_FILE, 'rb') { |f| seq.read(f) }
 
-    def test_read_strings
-	seq = MIDI::Sequence.new
-	File.open(SEQ_TEST_FILE, 'rb') { |f| seq.read(f) }
-	assert_equal('Sequence Name', seq.tracks[0].name)
-	assert_equal(MIDI::GM_PATCH_NAMES[0], seq.tracks[1].instrument)
+    names = []
+    num_tracks = -1
+    File.open(OUTPUT_FILE, 'wb') do |f|
+      seq.write(f) do |track, ntracks, i|
+        names << (track ? track.name : nil)
+        num_tracks = ntracks
+      end
     end
+    assert_equal(names, [nil, 'Sequence Name', 'My New Track'])
+    assert_equal(num_tracks, 2)
+  ensure
+    File.delete(OUTPUT_FILE) if File.exist?(OUTPUT_FILE)
+  end
 
+  def test_read_strings
+    seq = MIDI::Sequence.new
+    File.open(SEQ_TEST_FILE, 'rb') { |f| seq.read(f) }
+    assert_equal('Sequence Name', seq.tracks[0].name)
+    assert_equal(MIDI::GM_PATCH_NAMES[0], seq.tracks[1].instrument)
+  end
+
+  def test_preserve_meta_deltas
+    out_seq = MIDI::Sequence.new
+    out_track = MIDI::Track.new(out_seq)
+    out_seq.tracks << out_track
+    out_track.events << MIDI::Tempo.new(MIDI::Tempo.bpm_to_mpq(120))
+    # Normally copyright and sequence name events are at time 0, but non-zero
+    # start times are allowed.
+    out_track.events << MIDI::MetaEvent.new(MIDI::META_COPYRIGHT, '(C) 1950 Donald Duck', 100)
+    out_track.events << MIDI::MetaEvent.new(MIDI::META_SEQ_NAME, 'Quack, Track 1', 200)
+    out_track.events << MIDI::NoteOn.new(0, 64, 127, 0)
+    out_track.events << MIDI::NoteOff.new(0, 64, 127, 100)
+    File.open('/tmp/midilib_test.mid', 'wb') { |file| out_seq.write(file) }
+
+    # Although start times are not written out to the MIDI file, we
+    # calculate them because we are about to compare the out events with the
+    # newly-read events which will have their start times set.
+    out_track.recalc_times
+
+    in_seq = MIDI::Sequence.new
+    File.open(TEMPFILE, 'rb') { |file| in_seq.read(file) }
+    in_track = in_seq.tracks[0]
+    assert_equal(out_track.events.length, in_track.events.length)
+    out_track.events.each_with_index do |event, i|
+      assert_equal(event, in_track.events[i])
+    end
+  end
 end

data/test/test_mergesort.rb

@@ -0,0 +1,37 @@
+# Start looking for MIDI classes in the directory above this one.
+# This forces us to use the local copy of MIDI, even if there is
+# a previously installed version out there somewhere.
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'test/unit'
+require 'midilib/mergesort'
+
+class MergesortTester < Test::Unit::TestCase
+  def test_mergesort
+    track = MIDI::Track.new(nil)
+    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
+end

data/test/test_midifile.rb

@@ -8,30 +8,18 @@ require 'stringio'
 require 'midilib'
 
 class MIDI::IO::MIDIFile
-  def io=(io)
-    @io = io
-  end
-end
-if RUBY_VERSION < '1.9'
-  class StringIO
-    def readbyte
-      c = getc()
-      raise 'unexpected EOF' unless c
-      c
-    end
-  end
+  attr_writer :io
 end
 
 class MIDIFileTester < Test::Unit::TestCase
-
   def setup
     @m = MIDI::IO::MIDIFile.new
   end
 
   def test_msg_io
     io = StringIO.new
-    io.write("abcdef")
-    io.rewind()
+    io.write('abcdef')
+    io.rewind
     @m.io = io
     @m.msg_init
     @m.msg_read(6)
@@ -41,9 +29,9 @@ class MIDIFileTester < Test::Unit::TestCase
   def test_read32
     io = StringIO.new
     io.write("\0\0\0\6")
-    io.rewind()
+    io.rewind
     @m.io = io
-    assert_equal 6, @m.read32()
+    assert_equal 6, @m.read32
   end
 
   def test_write32
@@ -52,8 +40,7 @@ class MIDIFileTester < Test::Unit::TestCase
     $stdout = io
     @m.write32(6)
     $stdout = old_stdout
-    io.rewind()
+    io.rewind
     assert_equal "\0\0\0\6", io.string
   end
-
 end