jmtk 0.0.3.3-java

data/spec/mtk/lang/pitch_classes_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe MTK::Lang::PitchClasses do
+  let(:cases) {
+    [
+        [PitchClass['C'],  'C',   0],
+        [PitchClass['Db'], 'Db',  1],
+        [PitchClass['D'],  'D',   2],
+        [PitchClass['Eb'], 'Eb',  3],
+        [PitchClass['E'],  'E',   4],
+        [PitchClass['F'],  'F',   5],
+        [PitchClass['Gb'], 'Gb',  6],
+        [PitchClass['G'],  'G',   7],
+        [PitchClass['Ab'], 'Ab',  8],
+        [PitchClass['A'],  'A',   9],
+        [PitchClass['Bb'], 'Bb', 10],
+        [PitchClass['B'],  'B',  11],
+    ]
+  }
+
+  it "defines constants for the 12 pitch classes in the twelve-tone octave" do
+    cases.length.should == 12
+    cases.each do |const, name, value|
+      const.name.should == name
+      const.value.should == value
+    end
+  end
+
+  describe "PITCH_CLASSES" do
+    it "contains the 12 pitch class constants" do
+      PitchClasses::PITCH_CLASSES.length.should == 12
+      PitchClasses::PITCH_CLASSES.should == cases.map{ |const,_,__| const }
+    end
+
+    it "is immutable" do
+      lambda{ PitchClasses::PITCH_CLASSES << :something }.should raise_error
+    end
+  end
+
+  describe "PITCH_CLASS_NAMES" do
+    it "contains the names of the 12 pitch class constants" do
+      PitchClasses::PITCH_CLASS_NAMES.length.should == 12
+      PitchClasses::PITCH_CLASS_NAMES.should == cases.map{ |_,name,__| name }
+    end
+
+    it "is immutable" do
+      lambda{ PitchClasses::PITCH_CLASS_NAMES << :something }.should raise_error
+    end
+  end
+
+  describe ".[]" do
+    it "acts like PitchClass.[]" do
+      for name in PitchClasses::PITCH_CLASS_NAMES
+        PitchClasses[name].should == PitchClass[name]
+      end
+    end
+
+    it "returns nil for arguments it doesn't understand" do
+      PitchClasses[:invalid].should be_nil
+    end
+  end
+end

data/spec/mtk/lang/pitches_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe MTK::Lang::Pitches do
+
+  it "defines constants for the 128 notes in MIDI" do
+    Pitches.constants.length.should == 130 # there's also the PITCHES and PITCH_NAMES constants
+    Pitches::C_1.should == Pitch.from_s('C-1')
+    Pitches::D0.should == Pitch.from_s('D0')
+    Pitches::Eb1.should == Pitch.from_s('Eb1')
+    Pitches::G9.should == Pitch.from_s('g9')
+  end
+
+  describe "PITCHES" do
+    it "contains all 128 pitch constants" do
+      Pitches::PITCHES.length.should == 128
+      Pitches::PITCHES.should include Pitches::C_1
+      Pitches::PITCHES.should include Pitches::D0
+      Pitches::PITCHES.should include Pitches::Eb1
+      Pitches::PITCHES.should include Pitches::G9
+    end
+
+    it "is immutable" do
+      lambda{ Pitches::PITCHES << :something }.should raise_error
+    end
+  end
+
+  describe "PITCH_NAMES" do
+    it "contains all 128 pitch constants" do
+      Pitches::PITCH_NAMES.length.should == 128
+      Pitches::PITCH_NAMES.should include 'C_1'
+      Pitches::PITCH_NAMES.should include 'D0'
+      Pitches::PITCH_NAMES.should include 'Eb1'
+      Pitches::PITCH_NAMES.should include 'G9'
+    end
+
+    it "is immutable" do
+      lambda{ Pitches::PITCH_NAMES << :something }.should raise_error
+    end
+  end
+
+  describe ".[]" do
+    it "acts like Pitch.from_s for the names in PITCH_NAMES, and also treats '_' like '-'" do
+      for name in Pitches::PITCH_NAMES
+        Pitches[name].should == Pitch.from_s(name.sub('_','-')) # the constant names need to use underscores, but Pitch.from_s doesn't understand that
+        if name =~ /_/
+          Pitches[name.sub('_','-')].should == Pitch.from_s(name.sub('_','-')) # make sure '-' works too
+        end
+      end
+    end
+
+    it "returns nil for arguments it doesn't understand" do
+      Pitches[:invalid].should be_nil
+    end
+  end
+
+end

data/spec/mtk/lang/pseudo_constants_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe MTK::Lang::PseudoConstants do
+
+  module MockConstants
+    extend MTK::Lang::PseudoConstants
+    define_constant 'constant', :value
+  end
+
+  describe "define_constant" do
+    it "defines a method method in the module" do
+      MockConstants::constant.should == :value
+    end
+
+    it "defines a 'module_function'" do
+      MockConstants.constant.should == :value
+    end
+  end
+
+end

data/spec/mtk/lang/variable_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe MTK::Lang::Variable do
+
+  def var(*args)
+    ::MTK::Lang::Variable.new(*args)
+  end
+
+  describe '#name' do
+    it 'is the name the variable was constructed with' do
+      var('$').name.should == '$'
+      var('$$').name.should == '$$'
+    end
+
+    it 'cannot be changed after the variable is created' do
+      lambda{ var('$').name = '$$$' }.should raise_error
+    end
+  end
+
+  describe '#value' do
+    it 'is the value the variable was constructed with' do
+      var(:name, :value).value.should == :value
+    end
+
+    it 'can be changed after the variable is created' do
+      v = var(:name, :value)
+      v.value = 'foo'
+      v.value.should == 'foo'
+    end
+  end
+
+  describe '#==' do
+    it "is true when two variables' names are equal" do
+      var('$').should == var('$')
+    end
+
+    it "is false when two variables' names are not equal" do
+      var('$').should_not == var('$$')
+    end
+  end
+
+  describe '#to_s' do
+    it "includes just the variable name when there's no value" do
+      var('$').to_s.should == 'MTK::Lang::Variable<$>'
+    end
+
+    it "includes just the variable name and value when there's a value" do
+      var('x',1).to_s.should == 'MTK::Lang::Variable<x=1>'
+    end
+  end
+
+end

data/spec/mtk/numeric_extensions_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'mtk/numeric_extensions'
+
+describe Numeric do
+
+  describe "#to_pitch" do
+    it "acts like Pitch.from_f applied to the Numeric value" do
+      12.3.to_pitch.should == MTK::Core::Pitch.from_f(12.3)
+    end
+  end
+
+
+  describe "#to_pitch_class" do
+    it "acts like PitchClass.from_f applied to the Numeric value" do
+      6.to_pitch_class.should == MTK::Core::PitchClass.from_f(6)
+    end
+  end
+
+
+  describe "#to_duration" do
+    it "acts like Duration.from_f applied to the Numeric value" do
+      1.5.to_duration.should == MTK::Core::Duration.from_f(1.5)
+    end
+  end
+
+  describe "#beat" do
+    it "acts like #to_duration" do
+      1.beat.should == 1.to_duration
+    end
+  end
+
+  describe "#beats" do
+    it "acts like #to_duration" do
+      2.beats.should == 2.to_duration
+    end
+  end
+
+
+  describe "#to_intensity" do
+    it "acts like Intensity.from_f applied to the Numeric value" do
+      0.75.to_intensity.should == MTK::Core::Intensity.from_f(0.75)
+    end
+  end
+
+  describe "#percent_intensity" do
+    it "acts like Intensity.from_f applied to 1/100 of the Numeric value" do
+      75.percent_intensity.should == MTK::Core::Intensity.from_f(0.75)
+    end
+  end
+
+
+  describe "#to_interval" do
+    it "acts like Interval.from_f applied to the Numeric value" do
+      3.5.to_interval.should == MTK::Core::Interval.from_f(3.5)
+    end
+  end
+
+  describe '#semitone' do
+    it "acts like #to_interval" do
+      1.semitone.should == 1.to_interval
+    end
+  end
+
+  describe '#semitones' do
+    it "acts like #to_interval" do
+      2.semitones.should == 2.to_interval
+    end
+  end
+
+  describe "#cents" do
+    it "acts like Interval.from_f applied to 1/100 of the Numeric value" do
+      50.cents.should == MTK::Core::Interval.from_f(0.5)
+    end
+  end
+
+  describe "#octaves" do
+    it "acts like Interval.from_f applied to 12 times the Numeric value" do
+      2.octaves.should == MTK::Core::Interval.from_f(24)
+    end
+  end
+
+end
+

data/spec/mtk/patterns/chain_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe MTK::Patterns::Chain do
+
+  CHAIN = MTK::Patterns::Chain
+
+  describe '#next' do
+    it 'combines 2 basic attributes together' do
+      chain = CHAIN.new [C,q]
+      chain.next.should == [C,q]
+    end
+
+    it 'combines 3 basic attributes together' do
+      chain = CHAIN.new [C,q,mp]
+      chain.next.should == [C,q,mp]
+    end
+
+    it 'combines many basic attributes together, including duplicate types' do
+      chain = CHAIN.new [C,q,D,h,s,mp,fff]
+      chain.next.should == [C,q,D,h,s,mp,fff]
+    end
+
+    it 'raises StopIteration after a basic-attribute-only chain has called #next more than once' do
+      chain = CHAIN.new [C,q]
+      chain.next
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'combines a basic attribute with a pattern' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E), q]
+      chain.next.should == [C,q]
+      chain.next.should == [D,q]
+      chain.next.should == [E,q]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'combines 2 patterns' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E), Patterns.Sequence(w,h,q)]
+      chain.next.should == [C,w]
+      chain.next.should == [D,h]
+      chain.next.should == [E,q]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'combines 2 patterns, and returns #next until the last StopIteration of a nested Pattern occurs' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E), Patterns.Sequence(w,h,q,i)]
+      chain.next.should == [C,w]
+      chain.next.should == [D,h]
+      chain.next.should == [E,q]
+      chain.next.should == [C,i]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+
+    # TODO: more than 2 patterns, and more than 2 + basic attribute(s)
+
+
+    it 'combines Choice patterns with max_cycles' do
+      chain = CHAIN.new [Patterns.Choice(i,s), Patterns.Choice(C,D,E)], max_cycles:100
+      100.times do |time|
+        attrs = chain.next
+        attrs.length.should == 2
+        (attrs[0]==i or attrs[0]==s).should be_true
+        (attrs[1]==C or attrs[1]==D or attrs[1]==E).should be_true
+      end
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'combines Choice patterns and emits a only single combination of attributes by default' do
+      chain = CHAIN.new [Patterns.Choice(i,s), Patterns.Choice(C,D,E)]
+      chain.next
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'flattens attribute lists with nested chains' do
+      chain = CHAIN.new( [1, 2, CHAIN.new([3, CHAIN.new([4,5])])] )
+      chain.next.should == [1,2,3,4,5]
+    end
+
+    it 'throws StopIteration when any subpattern throws StopIteration with max_elements_exceeded' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E,F,G), Patterns.Sequence(w,h,q,i,  max_elements:3)]
+      chain.next.should == [C,w]
+      chain.next.should == [D,h]
+      chain.next.should == [E,q]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'throws StopIteration with max_elements_exceeded (edge case actual element length == max_elements)' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E,F,G), Patterns.Sequence(w,h,q,  max_elements:3)]
+      chain.next.should == [C,w]
+      chain.next.should == [D,h]
+      chain.next.should == [E,q]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+  end
+
+  describe '#rewind' do
+    it 'resets the state of the Chain' do
+      # compare with the #next, raises StopIteration test above
+      chain = CHAIN.new [C,q]
+      chain.next
+      chain.rewind
+      lambda{ chain.next }.should_not raise_error StopIteration
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+  end
+
+  # TODO: test the chain builder method in Patterns module
+
+end

data/spec/mtk/patterns/choice_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'set'
+
+describe MTK::Patterns::Choice do
+
+  CHOICE = MTK::Patterns::Choice
+
+  let(:elements) { [1,2,3] }
+  let(:choice) { CHOICE.new elements, max_cycles:500 }
+
+  describe "#next" do
+    it "throws StopIteration on the second call to #next, by default" do
+      choice = CHOICE.new elements
+      choice.next
+      lambda{ choice.next }.should raise_error StopIteration
+    end
+
+    it "randomly chooses one of the elements" do
+      choosen = Set.new
+      100.times do
+        element = choice.next
+        choosen << element
+      end
+      choosen.to_a.should =~ elements
+    end
+
+    it "does a weighted random selection when a weights list is passed in via constructor options[:weights]" do
+      choice = CHOICE.new elements, max_cycles:100, weights:[1,3,0] # only choose first 2 elements, and choose the second three times as often
+      choosen = Set.new
+      first_count, second_count = 0,0
+      100.times do
+        element = choice.next
+        choosen << element
+        first_count += 1 if element == elements[0]
+        second_count += 1 if element == elements[1]
+      end
+      choosen.to_a.should =~ elements[0..1]
+      (first_count + 10).should < second_count # this may occasional fail, but it seems unlikely
+    end
+
+    it "enumerates a choosen sub-sequence" do
+      choice = CHOICE.new [MTK::Patterns.Sequence(4,5,6)], max_cycles:10
+      choice.next.should == 4
+      choice.next.should == 5
+      choice.next.should == 6
+      choice.next.should == 4 # now it will select a new choice, but there's only one, so it will be the same
+      choice.next.should == 5
+      choice.next.should == 6
+    end
+  end
+
+end
+
+
+describe MTK::Patterns do
+
+  describe "#Choice" do
+    it "creates a Choice" do
+      MTK::Patterns.Choice(1,2,3).should be_a MTK::Patterns::Choice
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.Choice(1,2,3).elements.should == [1,2,3]
+    end
+  end
+
+  describe "#PitchChoice" do
+    it "creates a Choice" do
+      MTK::Patterns.PitchChoice(1,2,3).should be_a MTK::Patterns::Choice
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.PitchChoice(1,2,3).elements.should == [Pitch(1),Pitch(2),Pitch(3)]
+    end
+  end
+
+  describe "#IntensityChoice" do
+    it "creates a Choice" do
+      MTK::Patterns.IntensityChoice(1,2,3).should be_a MTK::Patterns::Choice
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.IntensityChoice(1,2,3).elements.should == [Intensity(1),Intensity(2),Intensity(3)]
+    end
+  end
+
+  describe "#DurationChoice" do
+    it "creates a Choice" do
+      MTK::Patterns.DurationChoice(1,2,3).should be_a MTK::Patterns::Choice
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.DurationChoice(1,2,3).elements.should == [q,h,h+q]
+    end
+  end
+
+end