musicality 0.1.0

data/spec/performance/conversion/note_sequence_extractor_spec.rb

@@ -0,0 +1,230 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe NoteSequenceExtractor do
+  describe '#initialize' do
+    it 'should clone original notes' do
+      notes = [ Note.quarter([C2]), Note.half, Note.half ]
+      extr = NoteSequenceExtractor.new(notes)
+      extr.notes[0].should eq(notes[0])
+      notes[0].transpose!(1)
+      extr.notes[0].should_not eq(notes[0])
+    end
+
+    it 'should maintain the same number of notes' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter, Note.half, Note.half ])
+      extr.notes.size.should eq 3
+    end
+
+    it 'should remove any bad ties (tying pitch does not exist in next note' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,E4], links: {C4 => Link::Tie.new}),
+          Note.quarter([E4]) ]
+      )
+      extr.notes[0].links.should_not have_key(C4)
+    end
+
+    it 'should replace any good ties with slurs' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,E4], links: {C4 => Link::Tie.new, E4 => Link::Tie.new}),
+          Note.quarter([C4,E4]) ]
+      )
+      extr.notes[0].links[C4].should be_a Link::Slur
+      extr.notes[0].links[E4].should be_a Link::Slur
+    end
+
+    it 'should remove dead slur/legato (where target pitch is non-existent)' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,E4], links: { C4 => Link::Slur.new(D4), E4 => Link::Legato.new(F4) }),
+          Note.quarter([C4]) ]
+      )
+      extr.notes[0].links.should be_empty
+    end
+
+    it 'should remove any link where the source pitch is missing' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,D4,E4,F4,G4], links: {
+            Bb4 => Link::Tie.new, Db4 => Link::Slur.new(C4),
+            Eb4 => Link::Legato.new(D4), Gb4 => Link::Glissando.new(E4),
+            Ab5 => Link::Portamento.new(F4)
+          }),
+          Note.quarter([C4,D4,E4,F4,G4])
+      ])
+      extr.notes[0].links.should be_empty
+    end
+
+    it 'should not remove portamento and glissando with non-existent target pitches' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,D4]),
+          Note.quarter([C4,D4,E4,F4,G4], links: {
+            C4 => Link::Tie.new, D4 => Link::Slur.new(Eb4),
+            E4 => Link::Legato.new(Gb4), F4 => Link::Glissando.new(A5),
+            G4 => Link::Portamento.new(Bb5)}) ]
+      )
+      extr.notes[-1].links.size.should eq 2
+      extr.notes[-1].links.should have_key(F4)
+      extr.notes[-1].links.should have_key(G4)
+    end
+  end
+
+  describe '#extract_sequences' do
+    context 'empty note array' do
+      it 'should return empty' do
+        seqs = NoteSequenceExtractor.new([]).extract_sequences
+        seqs.should be_empty
+      end
+    end
+
+    context 'array of only rest notes' do
+      it 'should return empty' do
+        notes = [ Note::quarter, Note::quarter ]
+        seqs = NoteSequenceExtractor.new(notes).extract_sequences
+        seqs.should be_empty
+      end
+    end
+
+    context 'array with only one note, single pitch' do
+      before :all do
+        @note = Note::quarter([C5])
+        @seqs = NoteSequenceExtractor.new([@note]).extract_sequences
+      end
+
+      it 'should return array with one sequence' do
+        @seqs.size.should eq 1
+      end
+
+      it 'should start offset 0' do
+        @seqs[0].start.should eq 0
+      end
+
+      it 'should stop offset <= note duration' do
+        @seqs[0].stop.should be <= @note.duration
+      end
+    end
+
+    context 'array with two slurred notes, single pitch' do
+      before :all do
+        @notes = [ Note.quarter([C5], articulation: SLUR), Note.quarter([D5]) ]
+        @seqs = NoteSequenceExtractor.new(@notes).extract_sequences
+      end
+
+      it 'should return array with one sequence' do
+        @seqs.size.should eq 1
+      end
+
+      it 'should start offset 0' do
+        @seqs[0].start.should eq 0
+      end
+
+      it 'should stop offset <= combined duration of the two notes' do
+        @seqs[0].stop.should be <= (@notes[0].duration + @notes[1].duration)
+      end
+    end
+
+    context 'array with one note, multiple pitches' do
+      before :all do
+        @note = Note.quarter([C5,D5,E5])
+        @seqs = NoteSequenceExtractor.new([@note]).extract_sequences
+      end
+
+      it 'should return array with as many sequences as pitches' do
+        @seqs.size.should eq @note.pitches.size
+      end
+
+      it 'should start the sequences at 0' do
+        @seqs.each {|s| s.start.should eq(0) }
+      end
+
+      it 'should end each sequence at or before note duration' do
+        @seqs.each {|s| s.stop.should be <= @note.duration }
+      end
+
+      it 'should put one pitch in each seq' do
+        @seqs.each {|s| s.pitches.size.should eq(1) }
+      end
+
+      it 'should assign a different pitch to each' do
+        @seqs.map {|seq| seq.pitches[0] }.sort.should eq @note.pitches.sort
+      end
+    end
+
+    context 'array with multiple notes and links' do
+      before :all do
+        @notes = [ Note.quarter([C3,E3], links: {
+          C3 => Link::Slur.new(D3), E3 => Link::Legato.new(F3)}),
+          Note.eighth([D3,F3]) ]
+        @seqs = NoteSequenceExtractor.new(@notes).extract_sequences
+      end
+
+      it 'should create a sequence for linked notes' do
+        @seqs.size.should eq(2)
+      end
+
+      it 'should add pitch at 0 from first note' do
+        @seqs[0].pitches.should have_key(0)
+        @notes[0].pitches.should include(@seqs[0].pitches[0])
+        @seqs[1].pitches.should have_key(0)
+        @notes[0].pitches.should include(@seqs[1].pitches[0])
+      end
+    end
+
+    context 'single note with single pitch, and glissando up' do
+      before :all do
+        @note = Note.whole([D3], links: { D3 => Link::Glissando.new(G3) })
+        @seqs = NoteSequenceExtractor.new([@note]).extract_sequences
+      end
+
+      it 'should produce one sequence' do
+        @seqs.size.should eq(1)
+      end
+
+      it 'should include pitches up to (not including) target pitch' do
+        @seqs[0].pitches.values.should include(D3,Eb3,E3,F3,Gb3)
+      end
+
+      it 'should produce sequence with duration <= note duration' do
+        @seqs[0].duration.should be <= @note.duration
+      end
+    end
+
+    context 'single note with single pitch, and glissando down' do
+      before :all do
+        @note = Note.whole([D3], links: { D3 => Link::Glissando.new(A2) })
+        @seqs = NoteSequenceExtractor.new([@note]).extract_sequences
+      end
+
+      it 'should produce one sequence' do
+        @seqs.size.should eq(1)
+      end
+
+      it 'should include pitches down to (not including) target pitch' do
+        @seqs[0].pitches.values.should include(D3,Db3,C3,B2,Bb2)
+      end
+
+      it 'should produce sequence with duration <= note duration' do
+        @seqs[0].duration.should be <= @note.duration
+      end
+    end
+
+    context 'two notes with single pitch, glissando up to pitch in second note' do
+      before :all do
+        @notes = [Note.whole([D3], links: { D3 => Link::Glissando.new(G3) }),
+                  Note.quarter([G3]) ]
+        @seqs = NoteSequenceExtractor.new(@notes).extract_sequences
+      end
+
+      it 'should produce a single sequence' do
+        @seqs.size.should eq(1)
+      end
+
+      it 'should includes pitches up through target pitch' do
+        @seqs[0].pitches.values.should include(D3,Eb3,E3,F3,Gb3,G3)
+      end
+
+      it 'should produce sequence with duration <= note1dur + note2dur' do
+        @seqs[0].duration.should be <= (@notes[0].duration + @notes[1].duration)
+      end
+    end
+  end
+end

data/spec/performance/conversion/portamento_converter_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe PortamentoConverter do
+  describe '.portamento_pitches' do
+    context 'start pitch <= target_pitch' do
+      [
+        [C4,E4,10],
+        [D2,G3,11],
+        [C4.transpose(0.5), A4.transpose(-0.3), 12],
+        [D5,D5,7],
+        [D5,D5.transpose(0.06),7],
+        [D5,D5.transpose(0.07),7],
+        [D5,D5.transpose(0.08),7],
+      ].each do |start,finish,step_size|
+        context "start at #{start.to_s}, end at #{finish.to_s}" do
+          pitches = PortamentoConverter.portamento_pitches(start,finish,step_size)
+          
+          it 'should begin at start pitch' do
+            pitches.first.should eq(start)
+          end
+          
+          it 'should space pitches using given cent step size' do
+            (1...pitches.size).each do |i|
+              diff = pitches[i].total_cents - pitches[i-1].total_cents
+              diff.should eq(step_size)
+            end
+          end
+          
+          it 'should end where one more step would be >= target pitch' do
+            diff = finish.total_cents - pitches.last.total_cents
+            diff.should be <= step_size
+          end
+        end
+      end
+    end
+
+    context 'start pitch > target_pitch' do
+      [
+        [E4,C4,10],
+        [G3,D2,11],
+        [A4,Bb3,12],
+        [A4.transpose(-0.33),Bb3.transpose(0.11),13],
+        [Bb3.transpose(0.64),Bb3.transpose(0.54),14],
+      ].each do |start,finish,step_size|
+        context "start at #{start.to_s}, end at #{finish.to_s}" do
+          pitches = PortamentoConverter.portamento_pitches(start,finish,step_size)
+          
+          it 'should begin at start pitch' do
+            pitches.first.should eq(start)
+          end
+          
+          it 'should space pitches using negative of given cent step size' do
+            (1...pitches.size).each do |i|
+              diff = pitches[i-1].total_cents - pitches[i].total_cents
+              diff.should eq(step_size)
+            end
+          end
+          
+          it 'should end where one more step would be <= target pitch' do
+            diff = pitches.last.total_cents - finish.total_cents
+            diff.should be <= step_size
+          end
+        end
+      end
+    end
+  end
+  
+  describe '.portamento_elements' do
+    before :all do
+      @dur = Rational(3,2)
+      @acc = false
+      @els = PortamentoConverter.portamento_elements(C4,F4,25,@dur,@acc)
+    end
+    
+    it 'should return an array of SlurredElement objects' do
+      @els.each {|el| el.should be_a SlurredElement }
+    end
+    
+    it 'should split up duration among elements' do
+      sum = @els.map {|el| el.duration }.inject(0,:+)
+      sum.should eq(@dur)
+    end
+    
+    it 'should set accented as given' do
+      els = PortamentoConverter.portamento_elements(C4,D4,10,1,false)
+      els.each {|el| el.accented.should eq(false) }
+      els = PortamentoConverter.portamento_elements(C4,D4,10,1,true)
+      els.each {|el| el.accented.should eq(true) }
+    end
+  end
+end

data/spec/performance/conversion/score_collator_spec.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe ScoreCollator do
+  describe '#collate_parts' do
+    before :all do
+      @part = Part.new(Dynamics::FF,
+        notes: [ Note.quarter([C2]),
+          Note.half([D2]),
+          Note.half([E2])
+      ])
+    end
+    
+    context 'first note starts before the segment start' do
+      context 'first note ends right at segment start' do
+        it 'should not be included in the part' do
+          score = Score::Measured.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new(["1/4".to_r..."5/4".to_r]))
+          collator = ScoreCollator.new(score)
+          parts = collator.collate_parts
+          notes = parts[1].notes
+          notes.size.should eq(@part.notes.size - 1)
+          notes[0].pitches[0].should eq D2
+          notes[1].pitches[0].should eq E2
+        end
+      end
+      
+      context 'first note ends after segment start' do
+        it 'should not be included in the part, and a rest is inserted' do
+          score = Score::Measured.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new(["1/8".to_r..."5/4".to_r]))
+          collator = ScoreCollator.new(score)
+          parts = collator.collate_parts
+          notes = parts[1].notes
+          notes.size.should eq(@part.notes.size)
+          notes[0].pitches.should be_empty
+          notes[0].duration.should eq "1/8".to_r
+          notes[1].pitches[0].should eq D2
+          notes[2].pitches[0].should eq E2
+        end
+      end
+    end
+    
+    context 'first note starts at segment start' do
+      context 'last note starts at program end' do
+        it 'should not be included in the part' do
+          score = Score::Measured.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new([0.to_r..."3/4".to_r]))
+          collator = ScoreCollator.new(score)
+          parts = collator.collate_parts
+          notes = parts[1].notes
+          notes.size.should eq(@part.notes.size - 1)
+        end
+      end
+      
+      context 'last note start before program end, but lasts until after' do
+        it 'should be included in the part, but truncated' do
+          score = Score::Measured.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new([0.to_r...1.to_r]))
+          collator = ScoreCollator.new(score)
+          parts = collator.collate_parts
+          notes = parts[1].notes
+          notes.size.should eq(@part.notes.size)
+          notes[-1].duration.should eq("1/4".to_r)
+        end
+      end
+      
+      context 'last note ends before program segment end' do
+        it 'should insert a rest between last note end and segment end' do
+          score = Score::Measured.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new([0.to_r..."6/4".to_r]))
+          collator = ScoreCollator.new(score)
+          parts = collator.collate_parts
+          notes = parts[1].notes
+          notes.size.should eq(@part.notes.size + 1)
+          notes[-1].pitches.should be_empty
+          notes[-1].duration.should eq("1/4".to_r)
+        end
+      end
+    end
+    
+    it 'should preserve links' do
+      notes = Note.split_parse("1Db4~Bb4")
+      score = Score::Measured.new(
+        FOUR_FOUR,120,
+        parts: { "lead" => Part.new(Dynamics::MP, notes: notes) },
+        program: Program.new([0..1,0..1]),
+      )
+      collator = ScoreCollator.new(score)
+      parts = collator.collate_parts
+      
+      notes = parts["lead"].notes
+      notes.size.should eq 2
+      notes.each do |note|
+        note.links.should have_key(Db4)
+        note.links[Db4].should be_a Link::Glissando
+      end
+    end
+  end
+  
+  describe '#collate_tempo_changes' do
+    before :all do
+      @change0 = Change::Immediate.new(120)
+      @change1 = Change::Immediate.new(200)
+      @change2 = Change::Gradual.new(100,1)
+    end
+    
+    context 'tempo change starts at end of program segment' do
+      it 'should not be included in the tempo changes' do
+        score = Score::Measured.new(FOUR_FOUR, 120, tempo_changes: {
+          1 => @change1, 2 => @change2 }, program: Program.new([0..2]))
+        collator = ScoreCollator.new(score)
+        tcs = collator.collate_tempo_changes
+        tcs.size.should eq 2
+        tcs[0.to_r].should eq @change0
+        tcs[1.to_r].should eq @change1
+      end
+    end
+
+    context 'tempo change starts and ends before segment' do
+      before :all do
+        score = Score::Measured.new(FOUR_FOUR, 120, tempo_changes: {
+          2 => @change2 }, program: Program.new([4..5]))
+        collator = ScoreCollator.new(score)
+        @tcs = collator.collate_tempo_changes
+      end
+      
+      it 'should not be included in the tempo changes' do
+        @tcs.size.should eq 1
+        @tcs[0.to_r].should be_a Change::Immediate
+      end
+      
+      it 'should be used as starting tempo change value' do
+        @tcs[0.to_r].value.should eq @change2.value
+      end
+    end
+    
+    context 'tempo change starts before segment, but ends during segment' do
+      it 'should e included in the tempo changes, but truncated' do
+        score = Score::Measured.new(FOUR_FOUR, 120, tempo_changes: {
+          1.5.to_r => @change2 }, program: Program.new([2..4]))
+        collator = ScoreCollator.new(score)
+        tcs = collator.collate_tempo_changes
+        tcs.size.should eq 1
+        tcs[0.to_r].value.should eq @change2.value
+        tcs[0.to_r].duration.should eq(0.5)
+      end
+    end
+    
+    context 'tempo change starts during segment, lasts until after' do
+      it 'should be included in the tempo changes, but truncated' do
+        score = Score::Measured.new(FOUR_FOUR, 120, tempo_changes: {
+          1 => @change1, 2 => @change2 }, program: Program.new([0..2.5]))
+        collator = ScoreCollator.new(score)
+        tcs = collator.collate_tempo_changes
+        tcs.size.should eq 3
+        tcs[0.to_r].should eq @change0
+        tcs[1.to_r].should eq @change1
+        tcs[2.to_r].value.should eq @change2.value
+        tcs[2.to_r].duration.should eq(0.5)
+      end
+    end
+  end
+
+  describe '#collate_meter_changes' do
+    it 'should behave just as #collate_tempo_changes' do
+      change0 = Change::Immediate.new(FOUR_FOUR)
+      change1 = Change::Immediate.new(THREE_FOUR)
+      change2 = Change::Immediate.new(SIX_EIGHT)
+      score = Score::Measured.new(FOUR_FOUR, 120, meter_changes: {
+        1 => change1, 2 => change2 }, program: Program.new([0...2]))
+      collator = ScoreCollator.new(score)
+      tcs = collator.collate_meter_changes
+      tcs.size.should eq 2
+      tcs[0.to_r].should eq change0
+      tcs[1.to_r].should eq change1
+    end
+  end
+end

data/spec/performance/midi/midi_util_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe MidiUtil do
+  describe '.pitch_to_notenum' do
+    context 'given C4' do
+      it 'should return 60' do
+        MidiUtil.pitch_to_notenum(C4).should eq(60)
+      end
+    end
+    
+    context 'given A4' do
+      it 'should return 69' do
+        MidiUtil.pitch_to_notenum(A4).should eq(69)
+      end
+    end
+    
+    context 'given octave below C0' do
+      it 'should return 0' do
+        MidiUtil.pitch_to_notenum(Pitch.new(octave:-1)).should eq(0)
+      end
+    end
+    
+    context 'given G9' do
+      it 'should return 127' do
+        MidiUtil.pitch_to_notenum(G9).should eq(127)
+      end
+    end
+    
+    context 'given pitch between C-1 to G9 range' do
+      it 'should pitch diff from C4 should equal notenum diff' do
+        c4_nn = MidiUtil.pitch_to_notenum(C4)
+         [C2,D2,Eb2,F2,A2,Bb3,C3,G3,Gb4,F5,A5,Bb5,C6].each do |pitch|
+          nn = MidiUtil.pitch_to_notenum(pitch)
+          C4.diff(pitch).should eq(c4_nn - nn)
+        end
+      end
+    end
+    
+    context 'given pitch outside C-1 to G9 range' do
+      it 'should raise error' do
+        expect { MidiUtil.pitch_to_notenum(Pitch.new(octave:-2)) }.to raise_error
+        expect { MidiUtil.pitch_to_notenum(Ab9) }.to raise_error
+      end
+    end
+  end
+  
+  describe '.dynamic_to_volume' do
+    context 'given 0' do
+      it 'should return 0' do
+        MidiUtil.dynamic_to_volume(0).should eq(0)
+      end
+    end
+    
+    context 'given 1' do
+      it 'should return 0' do
+        MidiUtil.dynamic_to_volume(1).should eq(127)
+      end
+    end
+    
+    context 'given 0.5' do
+      it 'should return 64' do
+        MidiUtil.dynamic_to_volume(0.5).should eq(64)
+      end
+    end
+  end
+  
+  describe 'note_velocity' do
+    context 'given true' do
+      it 'should return a higher value than when given false' do
+        MidiUtil.note_velocity(true).should be > MidiUtil.note_velocity(false)
+      end
+      
+      it 'should return a value between 0 and 127' do
+        MidiUtil.note_velocity(true).should be_between(0,127)
+      end
+    end
+    
+    context 'given false' do
+      it 'should return a value between 0 and 127' do
+        MidiUtil.note_velocity(false).should be_between(0,127)
+      end
+    end
+  end
+  
+  describe '.delta' do
+    context 'given 1/4' do
+      it 'should return the given ppqn' do
+        MidiUtil.delta(Rational(1,4),20).should eq(20)
+      end
+    end
+    
+    context 'given 1/2' do
+      it 'should return twice the given ppqn' do
+        MidiUtil.delta(Rational(1,2),20).should eq(40)
+      end
+    end
+    
+    context 'given 1/8' do
+      it 'should return half the given ppqn' do
+        MidiUtil.delta(Rational(1,8),20).should eq(10)
+      end
+    end
+    
+    it 'should return an integer' do
+      (0.1...1.1).step(0.1).each do |dur|
+        MidiUtil.delta(dur,100).should be_an(Integer)
+      end
+    end
+  end
+end

data/spec/performance/midi/part_sequencer_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe PartSequencer do
+  describe '#make_midi_track' do
+    before :all do
+      part = Part.new(Dynamics::PP, notes: "/4C4 /4D4 /8 /8D4 /8E4 /2C4".to_notes * 2)
+      @midi_seq = MIDI::Sequence.new
+      @part_name = "mypart"
+      @channel = 2
+      @ppqn = 200
+      @program_num = 22
+      @track = PartSequencer.new(part).make_midi_track(@midi_seq,@part_name,@channel,@ppqn,@program_num)
+    end
+    
+    it 'should return MIDI::Track' do
+      @track.should be_a MIDI::Track
+    end
+    
+    it 'should assign part name to track name' do
+      @track.name.should eq(@part_name)
+    end
+    
+    it 'should assign program number via ProgramChange event' do
+      event = @track.events.select { |x| x.is_a? MIDI::ProgramChange }.first
+      event.program.should eq(@program_num)
+    end
+    
+    it 'should assign the given channel number to all channel events' do
+      @track.events.each do |event|
+        if event.is_a? MIDI::ChannelEvent
+          event.channel.should eq(@channel)
+        end
+      end
+    end
+    
+    it 'should not add the track to the given midi seq' do
+      @midi_seq.tracks.should_not include(@track)
+    end
+  end
+end

data/spec/performance/midi/score_sequencer_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe ScoreSequencer do
+  describe '#initialize' do
+  end
+  
+  describe '#make_midi_seq' do
+    before :all do
+      @part1_name = "abc"
+      @part2_name = "def"
+      @part1 = Part.new(Dynamics::PP, notes: "/4C4 /4D4 /8 /8D4 /8E4 3/8C4".to_notes * 2)
+      @part2 = Part.new(Dynamics::FF, notes: "/4E4 3/4F4 /4E4".to_notes * 2)
+      @score = Score::Timed.new(program: Program.new([0..2.5]),
+                                parts: {@part1_name => @part2, @part2_name => @part2})
+      @instr_map = {@part1_name => 33, @part2_name => 25}
+      @midi_seq = ScoreSequencer.new(@score).make_midi_seq(@instr_map)
+    end
+    
+    it 'should return MIDI::Sequence' do
+      @midi_seq.should be_a MIDI::Sequence
+    end
+    
+    it 'should have 1 track for each part, plus one for score meta events' do
+      @midi_seq.tracks.size.should eq(@score.parts.size + 1)
+    end
+    
+    it 'should add a midi track for each part' do
+      @midi_seq.tracks[1].name.should eq(@part1_name)
+      @midi_seq.tracks[2].name.should eq(@part2_name)
+    end
+    
+    it 'should assign program number from given instrument map hash' do
+      [ @midi_seq.tracks[1], @midi_seq.tracks[2] ].each do |track|
+        prog_event = track.events.select {|x| x.is_a? MIDI::ProgramChange }.first
+        prog_event.program.should eq(@instr_map[track.name])
+      end
+    end
+    
+    it 'should assign different channel to each part track' do
+      chs_so_far = []
+      [ @midi_seq.tracks[1], @midi_seq.tracks[2] ].each do |track|
+        channel_events = track.events.select {|x| x.is_a? MIDI::ChannelEvent }
+        chs = channel_events.map {|event| event.channel }.uniq
+        chs.size.should eq 1
+        chs_so_far.should_not include(chs[0])
+        chs_so_far.push chs[0]
+      end
+    end
+  end
+end