jmtk 0.0.3.3-java

data/spec/mtk/groups/pitch_class_set_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+
+describe MTK::Groups::PitchClassSet do
+
+  PITCH_CLASS_SET = MTK::Groups::PitchClassSet
+
+  let(:pitch_classes) { [C,E,G] }
+  let(:pitch_class_set) { MTK::Groups::PitchClassSet.new(pitch_classes) }
+
+  it "is Enumerable" do
+    pitch_class_set.should be_a Enumerable
+  end
+
+  describe ".random_row" do
+    it "generates a 12-tone row" do
+      PITCH_CLASS_SET.random_row.should =~ PitchClasses::PITCH_CLASSES
+    end
+
+    it "generates a random 12-tone row (NOTE: very slight expected chance of test failure, if this fails run it again!)" do
+      # there's a 1/479_001_600 chance this will fail... whaddyagonnado??
+      PITCH_CLASS_SET.random_row.should_not == PITCH_CLASS_SET.random_row
+    end
+  end
+
+  describe ".all" do
+    it "is the set of all 12 pitch classes" do
+      PITCH_CLASS_SET.all.should == MTK.PitchClassSet(PitchClasses::PITCH_CLASSES)
+    end
+  end
+
+  describe ".new" do
+    it "maintains the pitch class collection exactly (preserves order and keeps duplicates)" do
+      PITCH_CLASS_SET.new([C, E, G, E, B, C]).pitch_classes.should == [C, E, G, E, B, C]
+    end
+  end
+
+  describe "#pitch_classes" do
+    it "is the list of pitch_classes contained in this set" do
+      pitch_class_set.pitch_classes.should == pitch_classes
+    end
+
+    it "is immutable" do
+      lambda { pitch_class_set.pitch_classes << D }.should raise_error
+    end
+
+    it "does not affect the immutabilty of the pitch class list used to construct it" do
+      pitch_classes << D
+      pitch_classes.length.should == 4
+    end
+
+    it "is not affected by changes to the pitch class list used to construct it" do
+      pitch_class_set # force construction before we modify the pitch_classes array
+      pitch_classes << D
+      pitch_class_set.pitch_classes.length.should == 3
+    end
+  end
+
+  describe "#to_a" do
+    it "is equal to #pitch_classes" do
+      pitch_class_set.to_a.should == pitch_class_set.pitch_classes
+    end
+
+    it "is mutable" do
+      (pitch_class_set.to_a << Bb).should == [C, E, G, Bb]
+    end
+  end
+
+  describe "#size" do
+    it "returns the number of pitch classes in the set" do
+      pitch_class_set.size.should == 3
+    end
+  end
+
+  describe "#length" do
+    it "behaves like #size" do
+      pitch_class_set.length.should == pitch_class_set.size
+    end
+  end
+
+  describe "#[]" do
+    it "accesses the individual pitch classes (like an Array)" do
+      pitch_class_set[0].should == C
+      pitch_class_set[1].should == E
+      pitch_class_set[2].should == G
+    end
+
+    it "returns nil for invalid indexes" do
+      pitch_class_set[pitch_class_set.size].should == nil
+    end
+  end
+
+  describe "#first" do
+    it "is #[0]" do
+      pitch_class_set.first.should == pitch_class_set[0]
+    end
+  end
+
+  describe "#last" do
+    it "is #[-1]" do
+      pitch_class_set.last.should == pitch_class_set[-1]
+    end
+  end
+
+  describe "#each" do
+    it "yields each pitch_class" do
+      pcs = []
+      pitch_class_set.each{|pc| pcs << pc }
+      pcs.should == pitch_classes
+    end
+  end
+
+  describe "#map" do
+    it "returns a PITCH_CLASS_SET with each PitchClass replaced with the results of the block" do
+      pitch_class_set.map{|pc| pc + 2}.should == [D, Gb, A]
+    end
+  end
+
+  describe '#transpose' do
+    it 'transposes by the given semitones' do
+      (pitch_class_set.transpose 4).should == MTK.PitchClassSet(E, Ab, B)
+    end
+  end
+
+  describe "#invert" do
+    it 'inverts all pitch_classes around the given center pitch' do
+      pitch_class_set.invert(G).should == MTK.PitchClassSet(D,Bb,G)
+    end
+
+    it 'inverts all pitches around the first pitch, when no center pitch is given' do
+      pitch_class_set.invert.should == MTK.PitchClassSet(C,Ab,F)
+    end
+  end
+
+  describe "#reverse" do
+    it "produces a PITCH_CLASS_SET with pitch classes in reverse order" do
+      pitch_class_set.reverse.should == MTK.PitchClassSet(G,E,C)
+    end
+  end
+
+  describe "#retrograde" do
+    it "acts like reverse" do
+      pitch_class_set.retrograde.should == pitch_class_set.reverse
+    end
+  end
+
+  describe "#intersection" do
+    it "produces a PITCH_CLASS_SET containing the common pitch classes from self and the argument" do
+      pitch_class_set.intersection(MTK.PitchClassSet(E,G,B)).should == MTK.PitchClassSet(E,G)
+    end
+  end
+
+  describe "#union" do
+    it "produces a PITCH_CLASS_SET containing the all pitch classes from either self or the argument" do
+      pitch_class_set.union(MTK.PitchClassSet(E,G,B)).should == MTK.PitchClassSet(C,E,G,B)
+    end
+  end
+
+  describe "#difference" do
+    it "produces a PITCH_CLASS_SET with the pitch classes from the argument removed" do
+      pitch_class_set.difference(MTK.PitchClassSet(E)).should == MTK.PitchClassSet(C,G)
+    end
+  end
+
+  describe "#symmetric_difference" do
+    it "produces a PITCH_CLASS_SET containing the pitch classes only in self or only in the argument" do
+      pitch_class_set.symmetric_difference(MTK.PitchClassSet(E,G,B)).should == MTK.PitchClassSet(C,B)
+    end
+  end
+
+  describe "#complement" do
+    it "produces the set of all PitchClasses not in the current set" do
+      pitch_class_set.complement.should =~ MTK.PitchClassSet(Db,D,Eb,F,Gb,Ab,A,Bb,B)
+    end
+  end
+
+  describe "#rotate" do
+    it "produces a PITCH_CLASS_SET that is rotated by the given offset" do
+      pitch_class_set.rotate(2).should == MTK.PitchClassSet(G,C,E)
+      pitch_class_set.rotate(-2).should == MTK.PitchClassSet(E,G,C)
+    end
+
+    it "rotates by 1 if no argument is given" do
+      pitch_class_set.rotate.should == pitch_class_set.rotate(1)
+    end
+  end
+
+  describe "#permute" do
+    it "randomly rearranges the PITCH_CLASS_SET order (NOTE: very slight expected chance of test failure, if this fails run it again!)" do
+      all_pcs = MTK.PitchClassSet(PitchClasses::PITCH_CLASSES)
+      permuted = all_pcs.permute
+      permuted.should =~ all_pcs
+      permuted.should_not == all_pcs # there's a 1/479_001_600 chance this will fail...
+    end
+  end
+
+  describe "#shuffle" do
+    it "behaves like permute (NOTE: very slight expected chance of test failure, if this fails run it again!)" do
+      all_pcs = MTK.PitchClassSet(PitchClasses::PITCH_CLASSES)
+      shuffled = all_pcs.shuffle
+      shuffled.should =~ all_pcs
+      shuffled.should_not == all_pcs # there's a 1/479_001_600 chance this will fail...
+    end
+  end
+
+  describe "#concat" do
+    it "appends the pitch classes from the other set" do
+      pitch_class_set.concat(MTK.PitchClassSet(D,E,F)).should == MTK.PitchClassSet(C,E,G,D,E,F)
+    end
+  end
+
+  describe "#normal_order" do
+    it "permutes the set so that the first and last pitch classes are as close together as possible" do
+      PITCH_CLASS_SET.new([E,A,C]).normal_order.should == [A,C,E]
+    end
+
+    it "breaks ties by minimizing the distance between the first and second-to-last pitch class" do
+      # 0,4,8,9,11
+      PITCH_CLASS_SET.new([C,E,Ab,A,B]).normal_order.should == [Ab,A,B,C,E]
+    end
+
+  end
+
+  describe "#normal_form" do
+    it "is transposes the #normal_order so that the first pitch class set is 0 (C)" do
+      PITCH_CLASS_SET.new([E,A,C]).normal_form.should == [0,3,7]
+    end
+
+    it "is invariant across reorderings of the pitch classes" do
+      PITCH_CLASS_SET.new([C,E,G]).normal_form.should == [0,4,7]
+      PITCH_CLASS_SET.new([E,C,G]).normal_form.should == [0,4,7]
+      PITCH_CLASS_SET.new([G,E,C]).normal_form.should == [0,4,7]
+    end
+
+    it "is invariant across transpositions" do
+      PITCH_CLASS_SET.new([C,Eb,G]).normal_form.should == [0,3,7]
+      PITCH_CLASS_SET.new([Db,E,Ab]).normal_form.should == [0,3,7]
+      PITCH_CLASS_SET.new([Bb,F,Db]).normal_form.should == [0,3,7]
+    end
+  end
+
+  describe "#==" do
+    it "is true if two pitch class sets contain the same set in the same order" do
+      pitch_class_set.should == MTK.PitchClassSet(C,E,G)
+    end
+
+    it "is false if two pitch class sets are not in the same order" do
+      pitch_class_set.should_not == MTK.PitchClassSet(C,G,E)
+    end
+
+    it "is false when if otherwise equal pitch class sets don't contain the same number of duplicates" do
+      PITCH_CLASS_SET.new([C, E, G]).should_not == PITCH_CLASS_SET.new([C, C, E, G])
+    end
+
+    it "is false if two pitch class sets do not contain the same pitch classes" do
+      pitch_class_set.should_not == MTK.PitchClassSet(C,E)
+    end
+
+    it "allows for direct comparison with Arrays" do
+       pitch_class_set.should == [C,E,G]
+    end
+  end
+
+  describe "#=~" do
+    it "is true if two pitch class sets contain the same set in the same order" do
+      pitch_class_set.should =~ MTK.PitchClassSet(C,E,G)
+    end
+
+    it "is true when all the pitch classes are equal, even with different numbers of duplicates" do
+      MTK::Groups::Melody.new([C, E, G]).should =~ MTK::Groups::Melody.new([C, C, E, G])
+    end
+
+    it "is true if two pitch class sets are not in the same order" do
+      pitch_class_set.should =~ MTK.PitchClassSet(C,G,E)
+    end
+
+    it "is false if two pitch class sets do not contain the same pitch classes" do
+      pitch_class_set.should_not =~ MTK.PitchClassSet(C,E)
+    end
+
+    it "allows for direct comparison with Arrays" do
+       pitch_class_set.should =~ [C,G,E]
+    end
+  end
+
+  describe ".span_between" do
+    it "is the distance in semitones between 2 pitch classes" do
+      PITCH_CLASS_SET.span_between(F, Bb).should == 5
+    end
+
+    it "assumes an ascending interval between the arguments (order of arguments matters)" do
+      PITCH_CLASS_SET.span_between(Bb, F).should == 7
+    end
+  end
+
+end
+
+describe MTK do
+
+  describe '#PitchClassSet' do
+
+    it "constructs a PitchClassSet" do
+      PitchClassSet(C,D).should be_a PITCH_CLASS_SET
+    end
+
+    it "acts like new for a single Array argument" do
+      PitchClassSet([C,D]).should == PITCH_CLASS_SET.new([C,D])
+    end
+
+    it "acts like new for multiple arguments, by treating them like an Array (splat)" do
+      PitchClassSet(C,D).should == PITCH_CLASS_SET.new([C,D])
+    end
+
+    it "handles an Array with elements that can be converted to Pitches" do
+      PitchClassSet(['C','D']).should == PITCH_CLASS_SET.new([C,D])
+    end
+
+    it "handles multiple arguments that can be converted to a Pitch" do
+      PitchClassSet(:C,:D).should == PITCH_CLASS_SET.new([C,D])
+    end
+
+    it "handles a single Pitch" do
+      PitchClassSet(C).should == PITCH_CLASS_SET.new([C])
+    end
+
+    it "handles single elements that can be converted to a Pitch" do
+      PitchClassSet('C').should == PITCH_CLASS_SET.new([C])
+    end
+
+    it "handles a a PitchClassSet" do
+      pitch_set = PITCH_CLASS_SET.new([C,D])
+      PitchClassSet(pitch_set).should == PitchClassSet([C,D])
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ PitchClassSet({:not => :compatible}) }.should raise_error
+    end
+
+  end
+
+end

data/spec/mtk/io/midi_file_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+require 'mtk/io/midi_file'
+require 'tempfile'
+
+describe MTK::IO::MIDIFile do
+
+  let(:test_mid) { File.join(File.dirname(__FILE__), '..', '..', 'test.mid') }
+
+  def tempfile
+    @tempfile ||= Tempfile.new 'MTK-midi_file_writer_spec'
+  end
+
+  after do
+    if @tempfile
+      @tempfile.close
+      @tempfile.unlink
+    end
+  end
+
+  def note_ons_and_offs(track)
+    note_ons, note_offs = [], []
+    for event in track.events
+      note_ons << event if event.is_a? MIDI::NoteOn
+      note_offs << event if event.is_a? MIDI::NoteOff
+    end
+    return note_ons, note_offs
+  end
+
+  describe "#to_timelines" do
+    it "converts a single-track MIDI file to an Array containing one Timeline" do
+      MIDIFile(test_mid).to_timelines.length.should == 1 # one track
+    end
+
+    it "converts note on/off messages to Note events" do
+      MIDIFile(test_mid).to_timelines.first.should == {
+        0.0 => [Note(C4,  0.25, 126/127.0)],
+        1.0 => [Note(Db4, 0.5,   99/127.0)],
+        2.0 => [Note(D4,  0.75,  72/127.0)],
+        3.0 => [Note(Eb4, 1.0,   46/127.0), Note(E4, 1.0, 46/127.0)]
+      }
+    end
+  end
+
+  describe "#write_timeline" do
+    it 'writes monophonic Notes in a Timeline to a MIDI file' do
+      MIDIFile(tempfile).write_timeline(
+        MTK::Events::Timeline.from_h({
+          0 => Note(C4, q, 0.7),
+          1 => Note(G4, q, 0.8),
+          2 => Note(C5, q, 0.9)
+        })
+      )
+
+      # Now let's parse the file and check some expectations
+      File.open(tempfile.path, 'rb') do |file|
+        seq = MIDI::Sequence.new
+        seq.read(file)
+        seq.tracks.size.should == 1
+
+        track = seq.tracks[0]
+        note_ons, note_offs = note_ons_and_offs(track)
+        note_ons.length.should == 3
+        note_offs.length.should == 3
+
+        note_ons[0].note.should == C4.to_i
+        note_ons[0].velocity.should be_within(0.5).of(127*0.7)
+        note_offs[0].note.should == C4.to_i
+        note_ons[0].time_from_start.should == 0
+        note_offs[0].time_from_start.should == 480
+
+        note_ons[1].note.should == G4.to_i
+        note_ons[1].velocity.should be_within(0.5).of(127*0.8)
+        note_offs[1].note.should == G4.to_i
+        note_ons[1].time_from_start.should == 480
+        note_offs[1].time_from_start.should == 960
+
+        note_ons[2].note.should == C5.to_i
+        note_ons[2].velocity.should be_within(0.5).of(127*0.9)
+        note_offs[2].note.should == C5.to_i
+        note_ons[2].time_from_start.should == 960
+        note_offs[2].time_from_start.should == 1440
+      end
+    end
+
+    it 'writes polyphonic (simultaneous) Notes in a Timeline to a MIDI file' do
+      MIDIFile(tempfile).write_timeline(
+        MTK::Events::Timeline.from_h({
+          0 => [Note(C4,q,0.5), Note(E4,q,0.5)],
+          2.0 => [Note(G4,h,1), Note(B4,h,1), Note(D5,h,1)]
+        })
+      )
+
+      # Now let's parse the file and check some expectations
+      File.open(tempfile.path, 'rb') do |file|
+        seq = MIDI::Sequence.new
+        seq.read(file)
+        seq.tracks.size.should == 1
+
+        track = seq.tracks[0]
+        note_ons, note_offs = note_ons_and_offs(track)
+        note_ons.length.should == 5
+        note_offs.length.should == 5
+
+        note_ons[0].note.should == C4.to_i
+        note_offs[0].note.should == C4.to_i
+        note_ons[0].velocity.should == 64
+        note_ons[0].time_from_start.should == 0
+        note_offs[0].time_from_start.should == 480
+
+        note_ons[1].note.should == E4.to_i
+        note_offs[1].note.should == E4.to_i
+        note_ons[1].velocity.should == 64
+        note_ons[1].time_from_start.should == 0
+        note_offs[1].time_from_start.should == 480
+
+        note_ons[2].note.should == G4.to_i
+        note_offs[2].note.should == G4.to_i
+        note_ons[2].velocity.should == 127
+        note_ons[2].time_from_start.should == 960
+        note_offs[2].time_from_start.should == 1920
+
+        note_ons[3].note.should == B4.to_i
+        note_offs[3].note.should == B4.to_i
+        note_ons[3].velocity.should == 127
+        note_ons[3].time_from_start.should == 960
+        note_offs[3].time_from_start.should == 1920
+
+        note_ons[4].note.should == D5.to_i
+        note_offs[4].note.should == D5.to_i
+        note_ons[4].velocity.should == 127
+        note_ons[4].time_from_start.should == 960
+        note_offs[4].time_from_start.should == 1920
+      end
+    end
+
+    it 'ignores rests (events with negative duration)' do
+      MIDIFile(tempfile).write_timeline(
+        MTK::Events::Timeline.from_h({
+          0 => Note(C4, q, 0.7),
+          1 => Note(G4, -q, 0.8), # this is a rest because it has a negative duration
+          2 => Note(C5, q, 0.9)
+        })
+      )
+
+      # Now let's parse the file and check some expectations
+      File.open(tempfile.path, 'rb') do |file|
+        seq = MIDI::Sequence.new
+        seq.read(file)
+        seq.tracks.size.should == 1
+
+        track = seq.tracks[0]
+        note_ons, note_offs = note_ons_and_offs(track)
+        note_ons.length.should == 2
+        note_offs.length.should == 2
+
+        note_ons[0].note.should == C4.to_i
+        note_ons[0].velocity.should be_within(0.5).of(127*0.7)
+        note_offs[0].note.should == C4.to_i
+        note_ons[0].time_from_start.should == 0
+        note_offs[0].time_from_start.should == 480
+
+        note_ons[1].note.should == C5.to_i
+        note_ons[1].velocity.should be_within(0.5).of(127*0.9)
+        note_offs[1].note.should == C5.to_i
+        note_ons[1].time_from_start.should == 960
+        note_offs[1].time_from_start.should == 1440
+      end
+    end
+  end
+
+  describe "#write_timelines" do
+    it "writes a multitrack MIDI file" do
+      MIDIFile(tempfile).write_timelines([
+        MTK::Events::Timeline.from_h({
+          0 => Note(C4, q, 0.7),
+          1.0 => Note(G4, q, 0.8),
+        }),
+        MTK::Events::Timeline.from_h({
+          1 => Note(C5, h, 0.9),
+          2 => Note(D5, h, 1),
+        }),
+      ])
+
+      # Now let's parse the file and check some expectations
+      File.open(tempfile.path, 'rb') do |file|
+        seq = MIDI::Sequence.new
+        seq.read(file)
+        seq.tracks.size.should == 2
+
+        track = seq.tracks[0]
+        note_ons, note_offs = note_ons_and_offs(track)
+        note_ons.length.should == 2
+        note_offs.length.should == 2
+
+        note_ons[0].note.should == C4.to_i
+        note_ons[0].velocity.should be_within(0.5).of(127*0.7)
+        note_offs[0].note.should == C4.to_i
+        note_ons[0].time_from_start.should == 0
+        note_offs[0].time_from_start.should == 480
+
+        note_ons[1].note.should == G4.to_i
+        note_ons[1].velocity.should be_within(0.5).of(127*0.8)
+        note_offs[1].note.should == G4.to_i
+        note_ons[1].time_from_start.should == 480
+        note_offs[1].time_from_start.should == 960
+
+        track = seq.tracks[1]
+        note_ons, note_offs = note_ons_and_offs(track)
+        note_ons.length.should == 2
+        note_offs.length.should == 2
+
+        note_ons[0].note.should == C5.to_i
+        note_ons[0].velocity.should be_within(0.5).of(127*0.9)
+        note_offs[0].note.should == C5.to_i
+        note_ons[0].time_from_start.should == 480
+        note_offs[0].time_from_start.should == 1440
+
+        note_ons[1].note.should == D5.to_i
+        note_ons[1].velocity.should == 127
+        note_offs[1].note.should == D5.to_i
+        note_ons[1].time_from_start.should == 960
+        note_offs[1].time_from_start.should == 1920
+      end
+    end
+  end
+
+  describe "#write" do
+    it "calls write_timeline when given a Timeline" do
+      midi_file = MIDIFile(nil)
+      timeline =  MTK::Events::Timeline.new
+      midi_file.should_receive(:write_timeline).with(timeline)
+      midi_file.write(timeline)
+    end
+
+    it "calls write_timelines when given an Array" do
+      midi_file = MIDIFile(nil)
+      timelines = [MTK::Events::Timeline.new]
+      midi_file.should_receive(:write_timelines).with(timelines)
+      midi_file.write(timelines)
+    end
+  end
+
+end