jmtk 0.0.3.3-java

data/spec/mtk/events/event_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe MTK::Events::Event do
+
+  EVENT = MTK::Events::Event
+
+  let(:type) { :type }
+  let(:duration) { 2.5 }
+  let(:options) { {:number => 1, :value => 0.5, :duration => duration, :channel => 0} }
+  let(:event) { EVENT.new type, options }
+  let(:hash) { options.merge({:type => type}) }
+
+
+  describe "#type" do
+    it "is the first argument passed to AbstractEvent.new" do
+      event.type.should == type
+    end
+
+    it "is a read-only attribute" do
+      lambda{ event.type = :anything }.should raise_error
+    end
+  end
+
+  describe "#value" do
+    it "is the value of the :value key in the options hash passed to AbstractEvent.new" do
+      event.value.should == options[:value]
+    end
+
+    it "defaults to nil" do
+      EVENT.new(type).value.should be_nil
+    end
+  end
+
+  describe "#value=" do
+    it "sets #value" do
+      event.value = 42
+      event.value.should == 42
+    end
+  end
+
+  describe "#duration" do
+    it "is the value of the :duration key in the options hash passed to AbstractEvent.new" do
+      event.duration.should == options[:duration]
+    end
+
+    it "defaults to 0" do
+      EVENT.new(type).duration.should == 0
+    end
+  end
+
+  describe "#duration=" do
+    it "sets #duration" do
+      event.duration = 42
+      event.duration.should == 42
+    end
+  end
+
+  describe "#number" do
+    it "is the value of the :number key in the options hash passed to AbstractEvent.new" do
+      event.number.should == options[:number]
+    end
+
+    it "defaults to nil" do
+      EVENT.new(type).number.should be_nil
+    end
+  end
+
+  describe "#number=" do
+    it "sets #number" do
+      event.number = 42
+      event.number.should == 42
+    end
+  end
+
+  describe "#channel" do
+    it "is the value of the :channel key in the options hash passed to AbstractEvent.new" do
+      event.channel.should == options[:channel]
+    end
+
+    it "defaults to nil" do
+      EVENT.new(type).channel.should be_nil
+    end
+  end
+
+  describe "#channel=" do
+    it "sets #channel" do
+      event.channel = 42
+      event.channel.should == 42
+    end
+  end
+
+  describe "#midi_value" do
+    it "is the @value * 127, rounded to the nearest integer" do
+      event.midi_value.should == (options[:value]*127).round
+    end
+
+    it "defaults to 0 when the @value is nil" do
+      EVENT.new(type).midi_value.should == 0
+    end
+
+    it "enforces a minimum of 0" do
+      event.value = -2
+      event.midi_value.should == 0
+    end
+
+    it "enforces a maximum of 127" do
+      event.value = 2
+      event.midi_value.should == 127
+    end
+  end
+
+  describe "#midi_value=" do
+    it "sets #value to the argument/127.0" do
+      event.midi_value = 100
+      event.value.should == 100/127.0
+    end
+  end
+
+  describe "#length" do
+    it "is the absolute value of duration" do
+      event.duration = -duration
+      event.length.should == duration
+    end
+
+    it "is 0 if the #duration is nil" do
+      event.duration = nil
+      event.length.should == 0
+    end
+  end
+
+  describe "#rest?" do
+    it "is true when the duration is negative" do
+      event.duration = -duration
+      event.rest?.should be_true
+    end
+
+    it "is false when the duration is positive" do
+      event.rest?.should be_false
+    end
+  end
+
+  describe "#instantaneous?" do
+    it "is true when the duration is 0" do
+      event.duration = 0
+      event.instantaneous?.should be_true
+    end
+
+    it "is true when the duration is nil" do
+      event.duration = nil
+      event.instantaneous?.should be_true
+    end
+
+    it "is false when the duration is positive" do
+      event.instantaneous?.should be_false
+    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
+    end
+  end
+
+  describe "#to_h" do
+    it "is a hash containing all the attributes of the Event" do
+      event.to_h.should == hash
+    end
+  end
+
+  describe "#duration_in_pulses" do
+    it "converts beats to pulses, given pulses_per_beat" do
+      EVENT.new(type, :duration => 1).duration_in_pulses(60).should == 60
+    end
+
+    it "rounds to the nearest pulse" do
+      EVENT.new(type, :duration => 1.5).duration_in_pulses(59).should == 89
+    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
+  end
+
+  describe "#==" do
+    it "is true when the type, number, value, duration and channel are equal" do
+      event.should == EVENT.new(type, options)
+    end
+    it "is false when the types are not equal" do
+      event.should_not == EVENT.new(:another_type, options)
+    end
+    it "is false when the numbers are not equal" do
+      event.should_not == EVENT.new(type, options.merge({:number => event.number + 1}))
+    end
+    it "is false when the values are not equal" do
+      event.should_not == EVENT.new(type, options.merge({:value => event.value * 0.5}))
+    end
+    it "is false when the durations are not equal" do
+      event.should_not == EVENT.new(type, options.merge({:duration => event.duration * 2}))
+    end
+    it "is false when the channels are not equal" do
+      event.should_not == EVENT.new(type, options.merge({:channel => event.channel + 1}))
+    end
+  end
+
+  describe "#to_s" do
+    it "has the value and duration to 2-decimal places" do
+      EVENT.new(type, :value => 0.454545, :duration => 0.789789).to_s.should == "Event(type, 0.45, 0.79)"
+    end
+    it "includes the #number when not nil" do
+      EVENT.new(type, :value => 0.454545, :duration => 0.789789, :number => 1).to_s.should == "Event(type[1], 0.45, 0.79)"
+    end
+  end
+
+  describe "#inspect" do
+    it "has the string values of value and duration" do
+      EVENT.new(:type, :value => 0.454545, :duration => 0.789789).inspect.should == "Event(type, 0.454545, 0.789789)"
+    end
+    it "includes the #number when not nil" do
+      EVENT.new(type, :value => 0.454545, :duration => 0.789789, :number => 1).inspect.should == "Event(type[1], 0.454545, 0.789789)"
+    end
+  end
+
+end

data/spec/mtk/events/note_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe MTK::Events::Note do
+
+  NOTE = Events::Note
+
+  let(:pitch) { C4 }
+  let(:intensity) { mf }
+  let(:duration) { Duration[2.5] }
+  let(:note) { NOTE.new(pitch, duration, intensity) }
+
+  describe "#pitch" do
+    it "is the pitch used to create the Note" do
+      note.pitch.should == pitch
+    end
+  end
+
+  describe "#pitch=" do
+    it "sets the pitch" do
+      note.pitch = D4
+      note.pitch.should == D4
+    end
+  end
+
+  describe "#intensity" do
+    it "is the intensity used to create the Event" do
+      note.intensity.should == intensity
+    end
+  end
+
+  describe "#intensity=" do
+    it "sets the intensity" do
+      note.intensity = fff
+      note.intensity.should == fff
+    end
+  end
+
+  describe "#velocity" do
+    it "converts intensities in the range 0.0-1.0 to a MIDI velocity in the range 0-127" do
+      NOTE.new(pitch, 0, 0).velocity.should == 0
+      NOTE.new(pitch, 0, 1).velocity.should == 127
+    end
+    it "rounds to the nearest MIDI velocity" do
+      NOTE.new(pitch, 0, 0.5).velocity.should == 64 # not be truncated to 63!
+    end
+  end
+
+  describe "#velocity=" do
+    it "sets the velocity" do
+      note.velocity = 100
+      note.velocity.should == 100
+    end
+  end
+
+  describe ".from_h" do
+    it "constructs a Note using a hash" do
+      NOTE.from_h({ :pitch => pitch, :intensity => intensity, :duration => duration }).should == note
+    end
+  end
+
+  describe '.from_midi' do
+    it "constructs a Note using a MIDI pitch and velocity" do
+      NOTE.from_midi(C4.to_i, mf.value*127, 2.5).should == note
+    end
+  end
+
+  describe "#to_h" do
+    it "is a hash containing all the attributes of the Note" do
+      hash = note.to_h
+      # hash includes some extra "baggage" for compatibility with AbstractEvent,
+      # so we'll just check the fields we care about:
+      hash[:pitch].should == pitch
+      hash[:intensity].should == intensity
+      hash[:duration].should == duration
+    end
+  end
+
+  describe '#transpose' do
+    it 'adds the given interval to the @pitch' do
+      (note.transpose 2).should == NOTE.new(D4, duration, intensity)
+    end
+  end
+
+  describe "#invert" do
+    context 'higher center pitch' do
+      it 'inverts the pitch around the given center pitch' do
+        note.invert(Pitch 66).should == NOTE.new(Pitch(72), duration, intensity)
+      end
+    end
+
+    context 'lower center pitch' do
+      it 'inverts the pitch around the given center pitch' do
+        note.invert(Pitch 54).should == NOTE.new(Pitch(48), duration, intensity)
+      end
+    end
+
+    it "returns the an equal note when given it's pitch as an argument" do
+      note.invert(note.pitch).should == note
+    end
+  end
+
+  describe "#==" do
+    it "is true when the pitches, intensities, and durations are equal" do
+      note.should == NOTE.new(pitch, duration, intensity)
+    end
+
+    it "is false when the pitches are not equal" do
+      note.should_not == NOTE.new(pitch + 1, duration, intensity)
+    end
+
+    it "is false when the intensities are not equal" do
+      note.should_not == NOTE.new(pitch, duration, intensity * 0.5)
+    end
+
+    it "is false when the durations are not equal" do
+      note.should_not == NOTE.new(pitch, duration * 2, intensity)
+    end
+  end
+
+  describe "#to_s" do
+    it "includes the #pitch, #intensity to 2 decimal places, and #duration to 2 decimal places" do
+      NOTE.new(C4, Duration(1/3.0), Intensity(1/3.0)).to_s.should == "Note(C4, 0.33 beat, 33%)"
+    end
+  end
+
+  describe "#inspect" do
+    it 'is "#<MTK::Events::Note:{object_id} @pitch={pitch.inspect}, @duration={duration.inspect}, @intensity={intensity.inspect}>"' do
+      duration = MTK.Duration(1/8.0)
+      intensity = MTK.Intensity(1/8.0)
+      note = NOTE.new(C4, duration, intensity)
+      note.inspect.should == "#<MTK::Events::Note:#{note.object_id} @pitch=#{C4.inspect}, @duration=#{duration.inspect}, @intensity=#{intensity.inspect}>"
+    end
+  end
+
+end
+
+
+describe MTK do
+
+  describe '#Note' do
+
+    it "acts like new for multiple arguments" do
+      Note(C4,q,mf).should == NOTE.new(C4,q,mf)
+    end
+
+    it "acts like new for an Array of arguments by unpacking (splatting) them" do
+      Note([C4,q,mf]).should == NOTE.new(C4,q,mf)
+    end
+
+    it "returns the argument if it's already a Note" do
+      note = NOTE.new(C4,q,mf)
+      Note(note).should be_equal(note)
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ Note({:not => :compatible}) }.should raise_error
+    end
+
+    it "handles out of order arguments for recognized types (Pitch, Duration, Intensity)" do
+      Note(q,mf,C4).should == NOTE.new(C4,q,mf)
+    end
+
+    it "fills in a missing duration type 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)
+    end
+
+  end
+
+end
+

data/spec/mtk/events/parameter_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe MTK::Events::Parameter do
+
+  PARAMETER = MTK::Events::Parameter
+
+
+  describe ".from_midi" do
+
+    context "poly pressure events" do
+
+      context "first arg is the status byte" do
+        it "parses :pressure #type on channel 0" do
+          PARAMETER.from_midi(0xA0, 0, 0).type.should == :pressure
+        end
+        it "parses :pressure #type on other channels" do
+          PARAMETER.from_midi(0xA0 | 5, 0, 0).type.should == :pressure
+        end
+        it "parses the #channel" do
+          PARAMETER.from_midi(0xA0 | 5, 0, 0).channel.should == 5
+        end
+      end
+
+      context "first arg is an array of [type,channel]" do
+        it "converts :poly_pressure to :pressure #type" do
+          PARAMETER.from_midi([:poly_pressure, 0], 0, 0).type.should == :pressure
+        end
+        it "extracts the #channel" do
+          PARAMETER.from_midi([:poly_pressure, 5], 0, 0).channel.should == 5
+        end
+      end
+
+      it "sets #number (pitch) to the data1 byte" do
+        PARAMETER.from_midi(0xA0, 100, 50).number.should == 100
+      end
+
+      it "set #value to the data2 byte / 127.0" do
+        PARAMETER.from_midi(0xA0, 100, 50).value.should == 50/127.0
+      end
+    end
+
+
+    context "control change events" do
+
+      context "first arg is the status byte" do
+        it "parses :control #type on channel 0" do
+          PARAMETER.from_midi(0xB0, 0, 0).type.should == :control
+        end
+        it "parses :control #type on other channels" do
+          PARAMETER.from_midi(0xB0 | 5, 0, 0).type.should == :control
+        end
+        it "parses the #channel" do
+          PARAMETER.from_midi(0xB0 | 5, 0, 0).channel.should == 5
+        end
+      end
+
+      context "first arg is an array of [type,channel]" do
+        it "converts :control_change :control #type" do
+          PARAMETER.from_midi([:control_change, 0], 0, 0).type.should == :control
+        end
+        it "extracts the #channel" do
+          PARAMETER.from_midi([:control_change, 5], 0, 0).channel.should == 5
+        end
+      end
+
+      it "sets #number to the data1 byte" do
+        PARAMETER.from_midi(0xB0, 100, 50).number.should == 100
+      end
+
+      it "set #value to the data2 byte / 127.0" do
+        PARAMETER.from_midi(0xB0, 100, 50).value.should == 50/127.0
+      end
+    end
+
+
+    context "program change events" do
+
+      context "first arg is the status byte" do
+        it "parses :program #type on channel 0" do
+          PARAMETER.from_midi(0xC0, 0, 0).type.should == :program
+        end
+        it "parses :program #type on other channels" do
+          PARAMETER.from_midi(0xC0 | 5, 0, 0).type.should == :program
+        end
+        it "parses the #channel" do
+          PARAMETER.from_midi(0xC0 | 5, 0, 0).channel.should == 5
+        end
+      end
+
+      context "first arg is an array of [type,channel]" do
+        it "converts :program_change :program #type" do
+          PARAMETER.from_midi([:program_change, 0], 0, 0).type.should == :program
+        end
+        it "extracts the #channel" do
+          PARAMETER.from_midi([:program_change, 5], 0, 0).channel.should == 5
+        end
+      end
+
+      it "sets #number to the data1 byte" do
+        PARAMETER.from_midi(0xC0, 100, 0).number.should == 100
+      end
+
+      it "does not set #value" do
+        PARAMETER.from_midi(0xC0, 100, 0).value.should be_nil
+      end
+    end
+
+
+    context "channel pressure events" do
+
+      context "first arg is the status byte" do
+        it "parses :pressure #type on channel 0" do
+          PARAMETER.from_midi(0xD0, 0, 0).type.should == :pressure
+        end
+        it "parses :pressure #type on other channels" do
+          PARAMETER.from_midi(0xD0 | 5, 0, 0).type.should == :pressure
+        end
+        it "parses the #channel" do
+          PARAMETER.from_midi(0xD0 | 5, 0, 0).channel.should == 5
+        end
+      end
+
+      context "first arg is an array of [type,channel]" do
+        it "converts :channel_pressure to :pressure #type" do
+          PARAMETER.from_midi([:channel_pressure, 0], 0, 0).type.should == :pressure
+        end
+        it "extracts the #channel" do
+          PARAMETER.from_midi([:channel_pressure, 5], 0, 0).channel.should == 5
+        end
+      end
+
+      it "does not set #number" do
+        PARAMETER.from_midi(0xD0, 50, 0).number.should be_nil
+      end
+
+      it "set #value to the data1 byte / 127.0" do
+        PARAMETER.from_midi(0xD0, 50, 0).value.should == 50/127.0
+      end
+    end
+
+
+    context "pitch bend events" do
+
+      context "first arg is the status byte" do
+        it "parses :bend #type on channel 0" do
+          PARAMETER.from_midi(0xE0, 0, 0).type.should == :bend
+        end
+        it "parses :bend #type on other channels" do
+          PARAMETER.from_midi(0xE0 | 5, 0, 0).type.should == :bend
+        end
+        it "parses the #channel" do
+          PARAMETER.from_midi(0xE0 | 5, 0, 0).channel.should == 5
+        end
+      end
+
+      context "first arg is an array of [type,channel]" do
+        it "converts :pitch_bend :bend #type" do
+          PARAMETER.from_midi([:pitch_bend, 0], 0, 0).type.should == :bend
+        end
+        it "extracts the #channel" do
+          PARAMETER.from_midi([:pitch_bend, 5], 0, 0).channel.should == 5
+        end
+      end
+
+      it "does not set #number" do
+        PARAMETER.from_midi(0xE0, 50, 0).number.should be_nil
+      end
+
+      it "sets #value by combining the data1 (lsb) and data2 (msb) bytes into a 14-bit int and then mapping to the range -1.0..1.0" do
+        PARAMETER.from_midi(0xE0,   0,   0).value.should == -1.0
+        PARAMETER.from_midi(0xE0,   0,  64).value.should == 0
+        PARAMETER.from_midi(0xE0, 127, 127).value.should == 1.0
+      end
+    end
+
+
+    context "unknown events" do
+      it "sets #type to :unknown" do
+        PARAMETER.from_midi(0xF0, 50, 100).type.should == :unknown
+      end
+
+      it "sets #number to the data1 byte" do
+        PARAMETER.from_midi(0xF0, 50, 100).number.should == 50
+      end
+
+      it "sets #value to the data2 byte / 127.0" do
+        PARAMETER.from_midi(0xF0, 50, 100).value.should == 100/127.0
+      end
+    end
+
+  end
+
+
+  describe "#midi_value" do
+    it "special cases :bend type events to map the range -1.0..1.0 back to a 14-bit int" do
+      PARAMETER.from_midi([:pitch_bend,0],   0,   0).midi_value.should == 0
+      PARAMETER.from_midi([:pitch_bend,0],   0,  64).midi_value.should == 8192
+      PARAMETER.from_midi([:pitch_bend,0], 127, 127).midi_value.should == 16383
+    end
+
+    it "maps back to the original midi value for other cases" do
+      PARAMETER.from_midi([:control_change,0], 0, 50).midi_value.should == 50
+    end
+  end
+
+
+  describe "#to_s" do
+    it "includes the #type, #number, and #value to 2 decimal places" do
+      PARAMETER.from_midi([:control_change,0], 50, 100).to_s.should == "Parameter(control[50], 0.79)"
+    end
+  end
+
+  describe "#inspect" do
+    it "includes the #type, #number, and #value.to_s" do
+      PARAMETER.from_midi([:control_change,0], 50, 100).inspect.should == "Parameter(control[50], #{100/127.0})"
+    end
+  end
+
+end
+