mtk 0.0.2 → 0.0.3

data/spec/mtk/sequencers/event_builder_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+describe MTK::Sequencers::EventBuilder do
+
+  EVENT_BUILDER = MTK::Sequencers::EventBuilder
+
+  let(:pitch) { EVENT_BUILDER::DEFAULT_PITCH }
+  let(:intensity) { EVENT_BUILDER::DEFAULT_INTENSITY }
+  let(:duration)  { EVENT_BUILDER::DEFAULT_DURATION }
+
+  def notes(*pitches)
+    pitches.map{|pitch| Note(pitch, intensity, duration) }
+  end
+
+  describe "#new" do
+    it "allows default pitch to be specified" do
+      event_builder = EVENT_BUILDER.new [Patterns.IntervalCycle(0)], :default_pitch => Gb4
+      event_builder.next.should == [Note(Gb4, intensity, duration)]
+    end
+    it "allows default intensity to be specified" do
+      event_builder = EVENT_BUILDER.new [Patterns.IntervalCycle(0)], :default_intensity => ppp
+      event_builder.next.should == [Note(pitch, ppp, duration)]
+    end
+    it "allows default duration to be specified" do
+      event_builder = EVENT_BUILDER.new [Patterns.IntervalCycle(0)], :default_duration => 5.25
+      event_builder.next.should == [Note(pitch, 5.25, intensity)]
+    end
+  end
+
+  describe "#next" do
+    it "builds a single-note list from a single-pitch pattern argument" do
+      event_builder = EVENT_BUILDER.new [Patterns.Cycle(C4)]
+      event_builder.next.should == notes(C4)
+    end
+
+    it "builds a list of notes from any pitches in the argument" do
+      event_builder = EVENT_BUILDER.new [Patterns.Cycle(C4), Patterns.Cycle(D4)]
+      event_builder.next.should == notes(C4, D4)
+    end
+
+    it "builds a list of notes from pitch sets" do
+      event_builder = EVENT_BUILDER.new [ Patterns.Cycle( Chord(C4,D4) ) ]
+      event_builder.next.should == notes(C4, D4)
+    end
+
+    it "builds notes from pitch classes and a default_pitch, selecting the nearest pitch class to the previous pitch" do
+      event_builder = EVENT_BUILDER.new [Patterns.Sequence(C,G,B,Eb,D,C)], :default_pitch => D3
+      notes = []
+      loop do
+        notes << event_builder.next
+      end
+      notes.flatten.should == notes(C3,G2,B2,Eb3,D3,C3)
+    end
+
+    it "defaults to a starting point of C4 (middle C)" do
+      event_builder = EVENT_BUILDER.new [Patterns.Sequence(C4)]
+      event_builder.next.should == notes(C4)
+    end
+
+    it "defaults to intensity 'o' when no intensities are given" do
+      event_builder = EVENT_BUILDER.new [Patterns.PitchSequence(C4, D4, E4), Patterns.DurationCycle(2)]
+      event_builder.next.should == [Note(C4, o, 2)]
+      event_builder.next.should == [Note(D4, o, 2)]
+      event_builder.next.should == [Note(E4, o, 2)]
+    end
+
+    it "defaults to duration 1 when no durations are given" do
+      event_builder =  EVENT_BUILDER.new [Patterns.PitchSequence(C4, D4, E4), Patterns.IntensityCycle(p,o)]
+      event_builder.next.should == [Note(C4, p, 1)]
+      event_builder.next.should == [Note(D4, o, 1)]
+      event_builder.next.should == [Note(E4, p, 1)]
+    end
+
+    it "builds notes from pitch class sets, selecting the nearest pitch classes to the previous/default pitch" do
+      pitch_class_sequence = MTK::Patterns::Sequence.new([PitchClassSet(C,G),PitchClassSet(B,Eb),PitchClassSet(D,C)])
+      event_builder = EVENT_BUILDER.new [pitch_class_sequence], :default_pitch => D3
+      event_builder.next.should == notes(C3,G3)
+      event_builder.next.should == notes(B3,Eb3)
+      event_builder.next.should == notes(D3,C3)
+    end
+
+    it "builds notes from by adding Numeric intervals in :pitch type Patterns to the previous Pitch" do
+      event_builder = EVENT_BUILDER.new [ Patterns.Sequence( C4, M3, m3, -P5 ) ]
+      nexts = []
+      loop { nexts << event_builder.next }
+      nexts.should == [notes(C4), notes(E4), notes(G4), notes(C4)]
+    end
+
+    it "builds notes from by adding Numeric intervals in :pitch type Patterns to all pitches in the previous Chord" do
+      event_builder = EVENT_BUILDER.new [ Patterns.Sequence( Chord(C4,Eb4), M3, m3, -P5) ]
+      nexts = []
+      loop { nexts << event_builder.next }
+      nexts.should == [notes(C4,Eb4), notes(E4,G4), notes(G4,Bb4), notes(C4,Eb4)]
+    end
+
+    it "builds notes from intensities" do
+      event_builder = EVENT_BUILDER.new [ Patterns.Cycle(C4), Patterns.Sequence(mf, p, fff) ]
+      nexts = []
+      loop { nexts += event_builder.next }
+      nexts.should == [Note(C4, mf, duration), Note(C4, p, duration), Note(C4, fff, duration)]
+    end
+
+    it "builds notes from durations" do
+      event_builder = EVENT_BUILDER.new [ Patterns.PitchCycle(C4), Patterns.DurationSequence(1,2,3) ]
+      nexts = []
+      loop { nexts += event_builder.next }
+      nexts.should == [Note(C4, intensity, 1), Note(C4, intensity, 2), Note(C4, intensity, 3)]
+    end
+
+    it "iterates through the pitch, intensity, and duration list in parallel to emit Notes" do
+      event_builder = EVENT_BUILDER.new [Patterns.PitchCycle(C4, D4, E4), Patterns.IntensityCycle(p, o), Patterns.DurationCycle(1,2,3,4)]
+      event_builder.next.should == [Note(C4, p, 1)]
+      event_builder.next.should == [Note(D4, o, 2)]
+      event_builder.next.should == [Note(E4, p, 3)]
+      event_builder.next.should == [Note(C4, o, 4)]
+      event_builder.next.should == [Note(D4, p, 1)]
+      event_builder.next.should == [Note(E4, o, 2)]
+    end
+
+    it "returns nil (for a rest) when it encounters a nil value" do
+      event_builder = EVENT_BUILDER.new [Patterns.PitchCycle(C4, D4, E4, F4, nil), Patterns.IntensityCycle(mp, mf, o, nil), Patterns.DurationCycle(1, 2, nil)]
+      event_builder.next.should == [Note(C4, mp, 1)]
+      event_builder.next.should == [Note(D4, mf, 2)]
+      event_builder.next.should be_nil
+      event_builder.next.should be_nil
+      event_builder.next.should be_nil
+    end
+
+    it "goes to the nearest Pitch for any PitchClasses in the pitch list" do
+      event_builder = EVENT_BUILDER.new [Patterns::Cycle(C4, F, C, G, C)]
+      event_builder.next.should == notes(C4)
+      event_builder.next.should == notes(F4)
+      event_builder.next.should == notes(C4)
+      event_builder.next.should == notes(G3)
+      event_builder.next.should == notes(C4)
+    end
+
+    it "does not endlessly ascend or descend when alternating between two pitch classes a tritone apart" do
+      event_builder = EVENT_BUILDER.new [Patterns::Cycle(C4, Gb, C, Gb, C)]
+      event_builder.next.should == notes(C4)
+      event_builder.next.should == notes(Gb4)
+      event_builder.next.should == notes(C4)
+      event_builder.next.should == notes(Gb4)
+      event_builder.next.should == notes(C4)
+    end
+
+    it "handles pitches and chords intermixed" do
+      event_builder = EVENT_BUILDER.new [Patterns.Cycle( Chord(C4, E4, G4), C4, Chord(D4, F4, A4) )]
+      event_builder.next.should == notes(C4,E4,G4)
+      event_builder.next.should == notes(C4)
+      event_builder.next.should == notes(D4,F4,A4)
+    end
+
+    it "adds numeric intervals to Chord" do
+      event_builder = EVENT_BUILDER.new [Patterns::Cycle( Chord(C4, E4, G4), M2 )]
+      event_builder.next.should == notes(C4,E4,G4)
+      event_builder.next.should == notes(D4,Gb4,A4)
+    end
+
+    it "goes to the nearest Pitch relative to the lowest note in the Chord for any PitchClasses in the pitch list" do
+      event_builder = EVENT_BUILDER.new [Patterns.Cycle( Chord(C4, E4, G4), F, D, Bb )]
+      event_builder.next.should == notes(C4,E4,G4)
+      event_builder.next.should == notes(F4)
+      event_builder.next.should == notes(D4)
+      event_builder.next.should == notes(Bb3)
+    end
+
+    it "uses the default_pitch when no pitch pattern is provided" do
+      event_builder = EVENT_BUILDER.new [Patterns.Cycle( mp, mf, o )], :default_pitch => G3
+      event_builder.next.should == [Note(G3,mp,1)]
+      event_builder.next.should == [Note(G3,mf,1)]
+      event_builder.next.should == [Note(G3,o,1)]
+    end
+
+    it "handles chains of sequences" do
+      event_builder = EVENT_BUILDER.new [ Patterns.Chain( Patterns.Sequence(C4,D4,E4), Patterns.Sequence(mp,mf,ff), Patterns.Sequence(q,h,w) ) ]
+      event_builder.next.should == [Note(C4,mp,q)]
+      event_builder.next.should == [Note(D4,mf,h)]
+      event_builder.next.should == [Note(E4,ff,w)]
+    end
+
+    it "enforces the max_interval option for rising intervals" do
+      event_builder = EVENT_BUILDER.new( [ Patterns.Sequence(C4,P5,P5,P5,P5,P5,P5,P5,P5,P5,P5,P5,P5)], max_interval:12 )
+      pitches = []
+      13.times{ pitches << event_builder.next[0].pitch }
+      pitches.should == [C4,G4,D4,A4,E4,B4,Gb4,Db4,Ab4,Eb4,Bb4,F4,C5]
+
+      event_builder = EVENT_BUILDER.new( [ Patterns.Sequence(C4,P5,P5,P5,P5,P5,P5,P5,P5,P5,P5,P5,P5)], max_interval:11 )
+      pitches = []
+      13.times{ pitches << event_builder.next[0].pitch }
+      pitches.should == [C4,G4,D4,A4,E4,B4,Gb4,Db4,Ab4,Eb4,Bb4,F4,C4]
+    end
+
+    it "enforces the max_interval option for falling intervals" do
+      event_builder = EVENT_BUILDER.new( [ Patterns.Sequence(C4,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5)], max_interval:12 )
+      pitches = []
+      13.times{ pitches << event_builder.next[0].pitch }
+      pitches.should == [C4,F3,Bb3,Eb3,Ab3,Db3,Gb3,B3,E3,A3,D3,G3,C3]
+
+      event_builder = EVENT_BUILDER.new( [ Patterns.Sequence(C4,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5,-P5)], max_interval:11 )
+      pitches = []
+      13.times{ pitches << event_builder.next[0].pitch }
+      pitches.should == [C4,F3,Bb3,Eb3,Ab3,Db3,Gb3,B3,E3,A3,D3,G3,C4]
+    end
+
+    it "adds chained durations together" do
+      event_builder = EVENT_BUILDER.new( [Patterns.Chain(h,q,i,s)] )
+      event_builder.next[0].duration.should == h+q+i+s
+    end
+
+    it "averages chained intensities together" do
+      event_builder = EVENT_BUILDER.new( [Patterns.IntensityChain(0.1, 0.2, 0.3, 0.4)] )
+      event_builder.next[0].intensity.should == Intensity(0.25)
+    end
+
+    it "defaults the intensity to the previous intensity" do
+      event_builder = EVENT_BUILDER.new(
+        [Patterns.Sequence(Patterns.Chain(C4,ppp,q), Patterns.Chain(D4,i), Patterns.Chain(E4,ff,h), Patterns.Chain(F4,i))]
+      )
+      notes = []
+      4.times{ notes += event_builder.next }
+      notes.should == [Note(C4,ppp,q), Note(D4,ppp,i), Note(E4,ff,h), Note(F4,ff,i)]
+    end
+
+    it "defaults the duration to the previous duration" do
+      event_builder = EVENT_BUILDER.new(
+          [Patterns.Sequence(Patterns.Chain(C4,ppp,h), Patterns.Chain(D4,mp), Patterns.Chain(E4,ff,s), Patterns.Chain(F4,mf))]
+      )
+      notes = []
+      4.times{ notes += event_builder.next }
+      notes.should == [Note(C4,ppp,h), Note(D4,mp,h), Note(E4,ff,s), Note(F4,mf,s)]
+    end
+  end
+
+  describe "#rewind" do
+    it "resets the state of the Chain" do
+      event_builder = EVENT_BUILDER.new [ Patterns.Sequence(C,P8) ]
+      event_builder.next.should == [Note(C4,intensity,duration)]
+      event_builder.next.should == [Note(C5,intensity,duration)]
+      event_builder.rewind
+      event_builder.next.should == [Note(C4,intensity,duration)]
+    end
+  end
+
+end

data/spec/mtk/sequencers/legato_sequencer_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe MTK::Sequencers::LegatoSequencer do
+
+  LEGATO_SEQUENCER = Sequencers::LegatoSequencer
+
+  let(:pitches)     { Patterns.PitchSequence(C4, D4, E4, C4) }
+  let(:durations)   { Patterns.DurationSequence(1, 0.5, 1.5, 4) }
+  let(:intensities) { Patterns.IntensitySequence(0.3, 0.6, 0.9, 1.0) }
+  let(:legato_sequencer) { LEGATO_SEQUENCER.new [pitches, durations, intensities] }
+
+
+  describe "#to_timeline" do
+    it "contains notes assembled from the given patterns, with Timeline time deltas from the max event duration at the previous step" do
+      legato_sequencer.to_timeline.should == Timeline.from_hash({
+        0   => Note(C4,1,0.3),
+        1.0 => Note(D4,0.5,0.6),
+        1.5 => Note(E4,1.5,0.9),
+        3.0 => Note(C4,4,1.0)
+      })
+    end
+
+    it "treats negative durations as rests" do
+      legato_sequencer = LEGATO_SEQUENCER.new( [pitches, Patterns.DurationSequence(-1,-0.5,-1.5,4), intensities] )
+      legato_sequencer.to_timeline.should == Timeline.from_hash({
+        3.0 => Note(C4,4,1.0)
+      })
+    end
+  end
+
+end
+
+
+describe MTK::Sequencers do
+
+  describe "#LegatoSequencer" do
+    it "creates a LegatoSequencer" do
+      MTK::Sequencers.LegatoSequencer(1,2,3, rhythm:1).should be_a MTK::Sequencers::LegatoSequencer
+    end
+
+    it "sets #patterns from the varargs" do
+      MTK::Sequencers.LegatoSequencer(1,2,3, rhythm:1).patterns.should == [1,2,3]
+    end
+  end
+end

data/spec/mtk/sequencers/rhythmic_sequencer_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe MTK::Sequencers::RhythmicSequencer do
+
+  RHYTHMIC_SEQUENCER = Sequencers::RhythmicSequencer
+
+  let(:pitches)     { Patterns.PitchSequence(C4, D4, E4, C4) }
+  let(:intensities) { Patterns.IntensitySequence(0.3, 0.6, 0.9, 1.0) }
+  let(:durations)   { Patterns.DurationSequence(1, 1, 2, 1) }
+  let(:rhythm)      { Patterns.RhythmSequence(0.5, 1.5, 4) }
+  let(:rhythmic_sequencer) { RHYTHMIC_SEQUENCER.new [pitches, intensities, durations], rhythm: rhythm }
+
+  describe "#new" do
+    it "defaults @max_steps to nil" do
+      rhythmic_sequencer.max_steps.should be_nil
+    end
+
+    it "sets @max_steps from the options hash" do
+      rhythmic_sequencer = RHYTHMIC_SEQUENCER.new [], rhythm: :mock_pattern, max_steps: 4
+      rhythmic_sequencer.max_steps.should == 4
+    end
+  end
+
+  describe "#to_timeline" do
+    it "returns a Timeline" do
+      rhythmic_sequencer.to_timeline.should be_a Timeline
+    end
+
+    it "contains notes assembled from the given patterns, with Timeline time deltas from the :rhythm type pattern" do
+      rhythmic_sequencer.to_timeline.should == Timeline.from_hash({
+        0 =>   Note(C4,1,0.3),
+        0.5 => Note(D4,1,0.6),
+        2.0 => Note(E4,2,0.9),
+        6.0 => Note(C4,1,1.0)
+      })
+    end
+
+
+    it "uses the absolute value of any negative durations in the rhythm pattern" do
+      timeline = RHYTHMIC_SEQUENCER.new( [pitches, intensities, durations], rhythm: Patterns.RhythmSequence(-0.5, 1.5, -4) ).to_timeline
+      timeline.should == Timeline.from_hash({
+        0 =>   Note(C4,1,0.3),
+        0.5 => Note(D4,1,0.6),
+        2.0 => Note(E4,2,0.9),
+        6.0 => Note(C4,1,1.0)
+      })
+    end
+  end
+
+  describe "#max_steps" do
+    it "controls the maximum number of times in the generated timeline" do
+      rhythmic_sequencer.max_steps = 2
+      rhythmic_sequencer.to_timeline.should == Timeline.from_hash({
+        0   => Note(C4,1,0.3),
+        0.5 => Note(D4,1,0.6)
+      })
+    end
+  end
+
+  describe "#rewind" do
+    it "rewinds the rhythm pattern (in addition to normal #rewind behavior)" do
+      rhythm.length.times{ rhythmic_sequencer.send :advance }
+      # now the next call would normally throw a StopIteration exception
+      rhythmic_sequencer.rewind
+      rhythm.length.times{ rhythmic_sequencer.send :advance }
+      # if we didn't get an exception, then #rewind did it's job
+    end
+  end
+
+end
+
+
+describe MTK::Sequencers do
+
+  describe "#RhythmicSequencer" do
+    it "creates a RhythmicSequencer" do
+      MTK::Sequencers.RhythmicSequencer(1,2,3, rhythm:1).should be_a MTK::Sequencers::RhythmicSequencer
+    end
+
+    it "sets #patterns from the varargs" do
+      MTK::Sequencers.RhythmicSequencer(1,2,3, rhythm:1).patterns.should == [1,2,3]
+    end
+  end
+end

data/spec/mtk/sequencers/sequencer_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe MTK::Sequencers::Sequencer do
+
+  ABSTRACT_SEQUENCER = Sequencers::Sequencer
+
+  class MockEventBuilder < Patterns::Chain
+    attr_accessor :mock_attribute
+  end
+
+  let(:patterns)  { [Patterns.PitchCycle(C4,D4)] }
+  let(:sequencer) { ABSTRACT_SEQUENCER.new patterns }
+  let(:pitch)     { ::MTK::Sequencers::EventBuilder::DEFAULT_PITCH }
+  let(:intensity) { ::MTK::Sequencers::EventBuilder::DEFAULT_INTENSITY }
+  let(:duration)  { ::MTK::Sequencers::EventBuilder::DEFAULT_DURATION }
+
+  describe "#new" do
+    it "defaults @max_steps to nil" do
+      sequencer.max_steps.should be_nil
+    end
+
+    it "sets @max_steps from the options hash" do
+      sequencer = ABSTRACT_SEQUENCER.new patterns, :max_steps => 4
+      sequencer.max_steps.should == 4
+    end
+
+    it "defaults @max_time to nil" do
+      sequencer.max_time.should be_nil
+    end
+
+    it "sets @max_time from the options hash" do
+      sequencer = ABSTRACT_SEQUENCER.new patterns, :max_time => 4
+      sequencer.max_time.should == 4
+    end
+
+    it "defaults @event_builder to ::MTK::Sequencers::EventBuilder" do
+      sequencer.event_builder.should be_a ::MTK::Sequencers::EventBuilder
+    end
+
+    it "sets @event_buidler from the options hash" do
+      sequencer = ABSTRACT_SEQUENCER.new patterns, :event_builder => MockEventBuilder
+      sequencer.event_builder.should be_a MockEventBuilder
+    end
+    
+    it "allows default pitch to be specified" do
+      sequencer = ABSTRACT_SEQUENCER.new [Patterns.IntervalCycle(0)], :default_pitch => Gb4
+      sequencer.next.should == [Note(Gb4, intensity, duration)]
+    end
+    it "allows default intensity to be specified" do
+      sequencer = ABSTRACT_SEQUENCER.new [Patterns.IntervalCycle(0)], :default_intensity => ppp
+      sequencer.next.should == [Note(pitch, ppp, duration)]
+    end
+    it "allows default duration to be specified" do
+      sequencer = ABSTRACT_SEQUENCER.new [Patterns.IntervalCycle(0)], :default_duration => 5.25
+      sequencer.next.should == [Note(pitch, intensity, 5.25)]
+    end  
+  end
+
+  describe "#event_builder" do
+    it "provides access to the internal EventBuilder" do
+      sequencer = ABSTRACT_SEQUENCER.new patterns, :event_builder => MockEventBuilder
+      sequencer.event_builder.mock_attribute = :value
+      sequencer.event_builder.mock_attribute.should == :value
+    end
+  end
+
+  describe "#to_timeline" do
+    it "combines pitch, intensity, and duration patterns into notes" do
+      pitches = Patterns.PitchSequence(C4, D4, E4)
+      intensities = Patterns.IntensitySequence(0.3, 0.7, 1.0)
+      durations = Patterns.DurationSequence(1, 2, 3)
+      sequencer = ABSTRACT_SEQUENCER.new [pitches, intensities, durations]
+      # default implementation just increments the time by 1 for each event (more interesting behavior is provided by subclasses)
+      sequencer.to_timeline.should == {
+        0.0 => [Note(C4,1,0.3)],
+        1.0 => [Note(D4,2,0.7)],
+        2.0 => [Note(E4,3,1.0)]
+      }
+    end
+
+    it "combines patterns of different types and lengths" do
+      pitches = Patterns.PitchSequence(C4, D4, E4, F4, G4, A4, B4, C5)
+      intensities = Patterns.IntensityCycle(0.5, 1.0)
+      durations = Patterns.DurationPalindrome(1, 2, 3)
+      sequencer = ABSTRACT_SEQUENCER.new [pitches, intensities, durations]
+      # default implementation just increments the time by 1 for each event (more interesting behavior is provided by subclasses)
+      sequencer.to_timeline.should == {
+        0.0 => [Note(C4,1,0.5)],
+        1.0 => [Note(D4,2,1.0)],
+        2.0 => [Note(E4,3,0.5)],
+        3.0 => [Note(F4,2,1.0)],
+        4.0 => [Note(G4,1,0.5)],
+        5.0 => [Note(A4,2,1.0)],
+        6.0 => [Note(B4,3,0.5)],
+        7.0 => [Note(C5,2,1.0)]
+      }
+    end
+
+    it "produces consistent results by reseting the patterns each time" do
+      pitches = Patterns.PitchSequence(C4, D4, E4)
+      intensities = Patterns.IntensityCycle(1)
+      durations = Patterns.DurationCycle(1, 2)
+      sequencer = ABSTRACT_SEQUENCER.new [pitches, intensities, durations]
+      sequencer.to_timeline.should == sequencer.to_timeline
+    end
+  end
+
+  describe "#time" do
+    it "is the current timeline time that the sequencer is generating events for" do
+      # AbstractSequencer just advances by 1 each step
+      sequencer.next # time doesn't advance until the second #next call
+      sequencer.time.should == 0
+      sequencer.next
+      sequencer.time.should == 1
+      sequencer.next
+      sequencer.time.should == 2
+    end
+  end
+
+  describe "#step" do
+    it "is the index for how many of times #next has been called (i.e. count starting from 0)" do
+      sequencer.step.should == -1 # -1 indicates #next has not yet been called
+      sequencer.next
+      sequencer.step.should == 0
+      sequencer.next
+      sequencer.step.should == 1
+      sequencer.next
+      sequencer.step.should == 2
+    end
+  end
+
+  describe "#next" do
+    it "returns a list of notes formed from the patterns in the sequencer"  do
+      sequencer.next.should == [Note(C4,intensity,duration)]
+      sequencer.next.should == [Note(D4,intensity,duration)]
+      sequencer.next.should == [Note(C4,intensity,duration)]
+    end
+
+    it "returns a filtered list of notes if the sequencer was constructed with a options[:filter] lambda" do
+      sequencer = ABSTRACT_SEQUENCER.new patterns, :filter => lambda{|events| events.map{|event| event.transpose(P8) } }
+      sequencer.next.should == [Note(C5,intensity,duration)]
+      sequencer.next.should == [Note(D5,intensity,duration)]
+    end
+
+    context "pitch patterns" do
+      it "adds Numeric elements (intervals) to the previous pitch" do
+        sequencer = ABSTRACT_SEQUENCER.new [Patterns.Cycle(C4, m2, M2, m3)]
+        sequencer.next.should == [Note(C4,intensity,duration)]
+        sequencer.next.should == [Note(C4+1,intensity,duration)]
+        sequencer.next.should == [Note(C4+1+2,intensity,duration)]
+        sequencer.next.should == [Note(C4+1+2+3,intensity,duration)]
+      end
+
+      it "returns a note with the given pitch when encountering a Pitch after another type" do
+        sequencer = ABSTRACT_SEQUENCER.new [Patterns.Cycle(C4, m2, C4)]
+        sequencer.next
+        sequencer.next
+        sequencer.next.should == [Note(C4,intensity,duration)]
+      end
+
+      it "goes to the nearest Pitch for any PitchClasses in the pitch list" do
+        sequencer = ABSTRACT_SEQUENCER.new [Patterns.Cycle(C4, F, C, G, C)]
+        sequencer.next.should == [Note(C4,intensity,duration)]
+        sequencer.next.should == [Note(F4,intensity,duration)]
+        sequencer.next.should == [Note(C4,intensity,duration)]
+        sequencer.next.should == [Note(G3,intensity,duration)]
+        sequencer.next.should == [Note(C4,intensity,duration)]
+      end
+
+      it "does not endlessly ascend or descend when alternating between two pitch classes a tritone apart" do
+        sequencer = ABSTRACT_SEQUENCER.new [Patterns.Cycle(C4, Gb, C, Gb, C)]
+        sequencer.next.should == [Note(C4,intensity,duration)]
+        sequencer.next.should == [Note(Gb4,intensity,duration)]
+        sequencer.next.should == [Note(C4,intensity,duration)]
+        sequencer.next.should == [Note(Gb4,intensity,duration)]
+        sequencer.next.should == [Note(C4,intensity,duration)]
+      end
+    end
+
+  end
+
+  describe "#rewind" do
+    it "resets the sequencer and its patterns" do
+      sequencer.next
+      sequencer.rewind
+      sequencer.step.should == -1
+      sequencer.time.should == 0
+      sequencer.next.should == [Note(C4,intensity,duration)]
+    end
+
+    it "resets pitches properly for patterns that rely on previous pitches" do
+      relative_pitch_pattern = Patterns.Sequence(C,P8)
+      sequencer = ABSTRACT_SEQUENCER.new [relative_pitch_pattern]
+      sequencer.next.should == [Note(C4,intensity,duration)]
+      sequencer.next.should == [Note(C5,intensity,duration)]
+      sequencer.rewind
+      sequencer.next.should == [Note(C4,intensity,duration)] # if the internal EventChain is not properly reset, the Note would be C5
+    end
+  end
+
+  describe "#max_steps" do
+    it "controls the maximum number of entries in the generated timeline" do
+      sequencer.max_steps = 2
+      sequencer.to_timeline.times.length.should == 2
+    end
+  end
+
+  describe "#max_time" do
+    it "controls the maximum time in the generated timeline" do
+      sequencer.max_time = 4
+      sequencer.to_timeline.times.last.should == 4
+    end
+  end
+
+end