jmtk 0.0.3.3-java → 0.4-java

data/spec/mtk/core/intensity_spec.rb

@@ -7,7 +7,7 @@ describe MTK::Core::Intensity do
 
   describe 'NAMES' do
     it "is the list of base intensity names available" do
-      Intensity::NAMES.should =~ %w( ppp pp p mp mf o ff fff )
+      Intensity::NAMES.should =~ %w( ppp pp p mp mf f ff fff )
     end
 
     it "is immutable" do

data/spec/mtk/events/event_spec.rb

@@ -12,7 +12,7 @@ describe MTK::Events::Event do
 
 
   describe "#type" do
-    it "is the first argument passed to AbstractEvent.new" do
+    it "is the first argument passed to Event.new" do
       event.type.should == type
     end
 
@@ -22,7 +22,7 @@ describe MTK::Events::Event do
   end
 
   describe "#value" do
-    it "is the value of the :value key in the options hash passed to AbstractEvent.new" do
+    it "is the value of the :value key in the options hash passed to Event.new" do
       event.value.should == options[:value]
     end
 
@@ -39,7 +39,7 @@ describe MTK::Events::Event do
   end
 
   describe "#duration" do
-    it "is the value of the :duration key in the options hash passed to AbstractEvent.new" do
+    it "is the value of the :duration key in the options hash passed to Event.new" do
       event.duration.should == options[:duration]
     end
 
@@ -56,7 +56,7 @@ describe MTK::Events::Event do
   end
 
   describe "#number" do
-    it "is the value of the :number key in the options hash passed to AbstractEvent.new" do
+    it "is the value of the :number key in the options hash passed to Event.new" do
       event.number.should == options[:number]
     end
 
@@ -73,7 +73,7 @@ describe MTK::Events::Event do
   end
 
   describe "#channel" do
-    it "is the value of the :channel key in the options hash passed to AbstractEvent.new" do
+    it "is the value of the :channel key in the options hash passed to Event.new" do
       event.channel.should == options[:channel]
     end
 
@@ -155,17 +155,6 @@ describe MTK::Events::Event do
     end
   end
 
-  describe "#duration_in_pulses" do
-    it "multiplies the #length times the argument and rounds to the nearest integer" do
-      event.duration_in_pulses(111).should == (event.length * 111).round
-    end
-
-    it "is 0 when the #duration is nil" do
-      event.duration = nil
-      event.duration_in_pulses(111).should == 0
-    end
-  end
-
   describe "from_h" do
     it "constructs an Event using a hash" do
       EVENT.from_h(hash).should == event
@@ -187,6 +176,11 @@ describe MTK::Events::Event do
       EVENT.new(type, :duration => 1.5).duration_in_pulses(59).should == 89
     end
 
+    it "is 0 when the #duration is nil" do
+      event.duration = nil
+      event.duration_in_pulses(111).should == 0
+    end
+
     it "is always positive (uses absolute value of the duration used to construct the Event)" do
       EVENT.new(type, :duration => -1).duration_in_pulses(60).should == 60
     end

data/spec/mtk/events/note_spec.rb

@@ -160,12 +160,12 @@ describe MTK do
       Note(q,mf,C4).should == NOTE.new(C4,q,mf)
     end
 
-    it "fills in a missing duration type from an number" do
+    it "fills in a missing duration argument from an number" do
       Note(C4,mf,5.25).should == NOTE.new(C4,MTK.Duration(5.25),mf)
     end
 
-    it '' do
-      Note(MTK::Lang::Pitches::C4, MTK::Lang::Intensities::o, 5.25).should == Note(C4, 5.25, 0.75)
+    it 'fills in a missing intensity and duration arguments from numbers' do
+      Note(MTK::Lang::Pitches::C4, MTK::Lang::Intensities::f, 5.25).should == Note(C4, 5.25, 0.75)
     end
 
   end

data/spec/mtk/events/rest_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe MTK::Events::Rest do
+
+  REST = MTK::Events::Rest
+
+  let(:duration) { -7.5 }
+  let(:channel) { 3 }
+  let(:rest) { REST.new duration, channel }
+  let(:hash) { {type: :rest, duration: duration, channel: channel} }
+
+
+  describe ".new" do
+    it "requires a duration as the first argument" do
+      lambda{ REST.new() }.should raise_error
+    end
+
+    it "coerces the duration to an MTK::Core::Duration" do
+      rest.duration.should be_a MTK::Core::Duration
+    end
+
+    it "forces the duration value negative to be a rest, if needed" do
+      REST.new(5).duration.should == -5
+    end
+  end
+
+  describe "#type" do
+    it "is :rest" do
+      rest.type.should == :rest
+    end
+
+    it "is a read-only attribute" do
+      lambda{ rest.type = :anything }.should raise_error
+    end
+  end
+
+  describe "#duration" do
+    it "is the value of the first argument to Rest.new, if the value was negative (indicating a rest)" do
+      rest.duration.should == duration
+    end
+  end
+
+  describe "#duration=" do
+    it "sets #duration" do
+      rest.duration = -42
+      rest.duration.should == -42
+    end
+
+    it "forces coerces argument to a MTK::Core::Duration" do
+      rest.duration = 42
+      rest.duration.should be_a MTK::Core::Duration
+    end
+
+    it "forces the duration value negative to be a rest, if needed" do
+      rest.duration = 42
+      rest.duration.should == -42
+    end
+  end
+
+  describe "#channel" do
+    it "is the value of the :channel key in the options hash passed to Rest.new" do
+      rest.channel.should == channel
+    end
+
+    it "defaults to nil" do
+      REST.new(duration).channel.should be_nil
+    end
+  end
+
+  describe "#channel=" do
+    it "sets #channel" do
+      rest.channel = 12
+      rest.channel.should == 12
+    end
+  end
+
+  describe "#midi_value" do
+    it "is nil" do
+      rest.midi_value.should be_nil
+    end
+  end
+
+  describe "#length" do
+    it "is the absolute value of duration" do
+      rest.duration = -5
+      rest.length.should == 5
+    end
+  end
+
+  describe "#rest?" do
+    it "is true when the duration is negative" do
+      rest.rest?.should be_true
+    end
+
+    it "is true event with a positive duration, because the duration was forced negative" do
+      rest.duration = 5
+      rest.rest?.should be_true
+    end
+  end
+
+  describe "from_h" do
+    it "constructs an Event using a hash" do
+      REST.from_h(hash).should == rest
+    end
+  end
+
+  describe "#to_h" do
+    it "is a hash containing all the attributes of the Rest" do
+      rest.to_h.should == hash
+    end
+  end
+
+
+  describe "#==" do
+    it "is true when the duration and channel are equal" do
+      rest.should == REST.new(duration, channel)
+    end
+
+    it "is false when the durations are not equal" do
+      rest.should_not == REST.new(duration+1, channel)
+    end
+
+    it "is false when the channels are not equal" do
+      rest.should_not == REST.new(duration, channel+1)
+    end
+  end
+
+  describe "#to_s" do
+    it "includes #duration to 2 decimal places" do
+      REST.new(Duration(-1/3.0)).to_s.should == "Rest(-0.33 beat)"
+    end
+  end
+
+  describe "#inspect" do
+    it 'is "#<MTK::Events::Rest:{object_id} @duration={duration.inspect}, @channel={channel}>"' do
+      rest.inspect.should == "#<MTK::Events::Rest:#{rest.object_id} @duration=#{rest.duration.inspect}, @channel=#{channel}>"
+    end
+  end
+
+end
+
+
+describe MTK do
+
+  describe '#Rest' do
+
+    it "acts like new for multiple arguments" do
+      MTK::Rest(4,2).should == REST.new(4,2)
+    end
+
+    it "acts like new for an Array of arguments by unpacking (splatting) them" do
+      MTK::Rest([4,2]).should == REST.new(4,2)
+    end
+
+    it "returns the argument if it's already a Rest" do
+      rest = REST.new(4,2)
+      MTK::Rest(rest).should be_equal(rest)
+    end
+
+    it "makes a Rest of the same duration and channel from other Event types" do
+      event = MTK::Events::Event.new(:event_type, duration:5, channel:3)
+      MTK::Rest(event).should == REST.new(5,3)
+    end
+
+    it "handles a single Numeric argument" do
+      MTK::Rest(4).should == REST.new(4)
+    end
+
+    it "handles a single Duration argument" do
+      MTK.Rest(MTK.Duration(4)).should == REST.new(4)
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ MTK::Rest({:not => :compatible}) }.should raise_error
+    end
+
+    it "handles out of order arguments for recognized Duration types" do
+      MTK::Rest(2,q).should == REST.new(q,2)
+    end
+
+  end
+
+end
+

data/spec/mtk/events/timeline_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe MTK::Events::Timeline do
 
   let(:note1) { Note(C4, p, 1) }
-  let(:note2) { Note(G4, o, 2) }
+  let(:note2) { Note(G4, f, 2) }
   let(:timeline_raw_data) { { 0.0 => note1, 1.0 => [note1, note2] } }
   let(:timeline_hash) { { 0.0 => [note1], 1.0 => [note1, note2] } }
   let(:timeline) { MTK::Events::Timeline.from_h(timeline_raw_data) }
@@ -425,6 +425,10 @@ describe MTK::Events::Timeline do
         (line =~ /=>/).should == arrow_position
       end
     end
+
+    it "returns empty string for empty timelines" do
+      MTK::Events::Timeline.new.to_s.should == ''
+    end
   end
 end
 

data/spec/mtk/io/midi_file_spec.rb

@@ -42,7 +42,7 @@ describe MTK::IO::MIDIFile do
   end
 
   describe "#write_timeline" do
-    it 'writes monophonic Notes in a Timeline to a MIDI file' do
+    it 'writes monophonic Notes in a Timeline to a MIDI format 0 file' do
       MIDIFile(tempfile).write_timeline(
         MTK::Events::Timeline.from_h({
           0 => Note(C4, q, 0.7),
@@ -56,6 +56,7 @@ describe MTK::IO::MIDIFile do
         seq = MIDI::Sequence.new
         seq.read(file)
         seq.tracks.size.should == 1
+        seq.format.should == 0
 
         track = seq.tracks[0]
         note_ons, note_offs = note_ons_and_offs(track)
@@ -82,6 +83,15 @@ describe MTK::IO::MIDIFile do
       end
     end
 
+    it 'writes a timeline that can be read in as an identical Timeline' do
+      timeline = MTK::Events::Timeline.from_h({
+        0 => Note(C4, q, 1)
+      })
+      MIDIFile(tempfile).write_timeline(timeline)
+      read_timeline = MIDIFile(tempfile).to_timelines.first
+      read_timeline.should == timeline
+    end
+
     it 'writes polyphonic (simultaneous) Notes in a Timeline to a MIDI file' do
       MIDIFile(tempfile).write_timeline(
         MTK::Events::Timeline.from_h({
@@ -169,7 +179,7 @@ describe MTK::IO::MIDIFile do
   end
 
   describe "#write_timelines" do
-    it "writes a multitrack MIDI file" do
+    it "writes a multitrack format 1 MIDI file" do
       MIDIFile(tempfile).write_timelines([
         MTK::Events::Timeline.from_h({
           0 => Note(C4, q, 0.7),
@@ -186,6 +196,7 @@ describe MTK::IO::MIDIFile do
         seq = MIDI::Sequence.new
         seq.read(file)
         seq.tracks.size.should == 2
+        seq.format.should == 1
 
         track = seq.tracks[0]
         note_ons, note_offs = note_ons_and_offs(track)

data/spec/mtk/io/midi_output_spec.rb

@@ -10,14 +10,15 @@ describe MTK::IO::MIDIOutput do
   let(:subject) { MockOuput.new(mock_device) }
 
   let(:mock_device) do
-    mock_device = mock(:device)
+    mock_device = double(:device)
     mock_device.stub(:open)
     mock_device
   end
 
   let(:scheduler) do
-    scheduler = mock(:scheduler)
+    scheduler = double(:scheduler)
     Gamelan::Scheduler.stub(:new).and_return scheduler
+    scheduler.stub(:stop).and_return :stop_scheduler
     scheduler
   end
 
@@ -28,14 +29,16 @@ describe MTK::IO::MIDIOutput do
   end
 
   def should_be_scheduled timed_data
+    explicitly_expected_stop_scheduler = false
     timed_data.each do |time,data|
+      explicitly_expected_stop_scheduler = true if data == :stop_scheduler
       scheduler.should_receive(:at) do |scheduled_time,&callback|
         scheduled_time.should == time
         callback.yield.should == data
       end
     end
-    scheduler.should_receive(:at) # end time, don't care about this here...
-    scheduler.should_receive(:run).and_return mock(:thread,:join=>nil)
+    scheduler.should_receive(:at) unless explicitly_expected_stop_scheduler # auto-handle stop_schedulerer if needed
+    scheduler.should_receive(:run).and_return double(:thread,:join=>nil)
   end
 
 
@@ -50,7 +53,8 @@ describe MTK::IO::MIDIOutput do
 
     it "handles note events" do
       should_be_scheduled 0 => [:note_on,  60, 127, 0],
-                          1 => [:note_off, 60, 127, 0]
+                          1 => [:note_on,  60,   0, 0]
+                          # 1 => [:note_off, 60, 127, 0] # for when we have proper note off support
       subject.play  MTK::Events::Timeline.from_h( 0 => Note(C4,fff,1) )
     end
 
@@ -82,21 +86,50 @@ describe MTK::IO::MIDIOutput do
     it "handles simultaneous events" do
       should_be_scheduled [
         [0, [:note_on,  60, 127, 0]],
-        [1, [:note_off, 60, 127, 0]],
+        [1, [:note_on,  60,   0, 0]],
+        # [1, [:note_off, 60, 127, 0]], # for when we have proper note off support
         [0, [:note_on,  67, 127, 0]],
-        [1, [:note_off, 67, 127, 0]]
+        [1, [:note_on,  67,   0, 0]],
+        # [1, [:note_off, 67, 127, 0]] # for when we have proper note off support
       ]
       subject.play [Note(C4,fff,1),Note(G4,fff,1)]
     end
 
     it "handles a list of timelines" do
       should_be_scheduled  0 => [:note_on,  60, 127, 0],
-                           1 => [:note_off, 60, 127, 0],
+                           1 => [:note_on,  60,   0, 0],
+                           #1 => [:note_off, 60, 127, 0], # for when we have proper note off support
                            2 => [:note_on,  67, 127, 0],
-                           3 => [:note_off, 67, 127, 0]
+                           3 => [:note_on,  67,   0, 0]
+                           #3 => [:note_off, 67, 127, 0] # for when we have proper note off support
       subject.play [ MTK::Events::Timeline.from_h( 0 => Note(C4,fff,1) ),  MTK::Events::Timeline.from_h( 2 => Note(G4,fff,1) )]
     end
 
+
+    it "stops the scheduler 2 beats after the last event" do
+      should_be_scheduled  0 => [:note_on,  60, 127, 0],
+                           1 => [:note_on,  60,   0, 0],
+                           #1 => [:note_off, 60, 127, 0], # for when we have proper note off support
+                           3 => :stop_scheduler
+      subject.play MTK::Events::Timeline.from_h( 0 => Note(C4,fff,1) )
+    end
+
+    it "stops the scheduler 2 beats after the longest of simultaneous final events" do
+      should_be_scheduled  [
+        [0,  [:note_on,  60, 127, 0]],
+        [1,  [:note_on,  60,   0, 0]],
+        #[1,  [:note_off, 60, 127, 0]], # for when we have proper note off support
+        [0,  [:note_on,  62, 127, 0]],
+        [3.5,[:note_on,  62,   0, 0]],
+        #[3.5,[:note_off, 62, 127, 0]], # for when we have proper note off support
+        [0,  [:note_on,  64, 127, 0]],
+        [2,  [:note_on,  64,   0, 0]],
+        #[2,  [:note_off, 64, 127, 0]], # for when we have proper note off support
+        [5.5, :stop_scheduler]
+      ]
+      subject.play MTK::Events::Timeline.from_h( 0 => [Note(C4,fff,1), Note(D4,fff,3.5), Note(E4,fff,2)] )
+    end
+
   end
 
 end