beats 1.2.0 → 1.2.1

data/test/pattern_test.rb

@@ -7,28 +7,22 @@ class PatternTest < Test::Unit::TestCase
   SECONDS_IN_MINUTE = 60.0
 
   def generate_test_data
-    kit = Kit.new("test/sounds")
-    kit.add("bass.wav",      "bass_mono_8.wav")
-    kit.add("snare.wav",     "snare_mono_8.wav")
-    kit.add("hh_closed.wav", "hh_closed_mono_8.wav")
-    kit.add("hh_open.wav",   "hh_open_mono_8.wav")
-    
     test_patterns = {}
     
     pattern = Pattern.new :blank
     test_patterns[:blank] = pattern
     
     pattern = Pattern.new :verse
-    pattern.track "bass.wav",      kit.get_sample_data("bass.wav"),      "X...X...X...XX..X...X...XX..X..."
-    pattern.track "snare.wav",     kit.get_sample_data("snare.wav"),     "..X...X...X...X.X...X...X...X..."
-    pattern.track "hh_closed.wav", kit.get_sample_data("hh_closed.wav"), "X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X."
-    pattern.track "hh_open.wav",   kit.get_sample_data("hh_open.wav"),   "X...............X..............X"
+    pattern.track "bass.wav",      "X...X...X...XX..X...X...XX..X..."
+    pattern.track "snare.wav",     "..X...X...X...X.X...X...X...X..."
+    pattern.track "hh_closed.wav", "X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X."
+    pattern.track "hh_open.wav",   "X...............X..............X"
     test_patterns[:verse] = pattern
     
     pattern = Pattern.new :staircase
-    pattern.track "bass.wav",      kit.get_sample_data("bass.wav"),      "X..."
-    pattern.track "snare.wav",     kit.get_sample_data("snare.wav"),     "X.."
-    pattern.track "hh_closed.wav", kit.get_sample_data("hh_closed.wav"), "X."
+    pattern.track "bass.wav",      "X..."
+    pattern.track "snare.wav",     "X.."
+    pattern.track "hh_closed.wav", "X."
     test_patterns[:staircase] = pattern
     
     return test_patterns
@@ -50,152 +44,58 @@ class PatternTest < Test::Unit::TestCase
     assert_equal(pattern.tracks.length, 3)
   end
 
-  def test_sample_length
-    test_patterns = generate_test_data()
-    
-    tick_sample_length = 13860.0
-    assert_equal(test_patterns[:blank].sample_length(tick_sample_length), 0)
-    assert_equal(test_patterns[:verse].sample_length(tick_sample_length), tick_sample_length * 32)
-    assert_equal(test_patterns[:staircase].sample_length(tick_sample_length), tick_sample_length * 4)
-
-    tick_sample_length = 6681.81818181818
-    assert_equal(test_patterns[:blank].sample_length(tick_sample_length), 0)
-    assert_equal(test_patterns[:verse].sample_length(tick_sample_length), (tick_sample_length * 32).floor)
-    assert_equal(test_patterns[:staircase].sample_length(tick_sample_length), (tick_sample_length * 4).floor)
-
-    tick_sample_length = 16134.1463414634
-    assert_equal(test_patterns[:blank].sample_length(tick_sample_length), 0)
-    assert_equal(test_patterns[:verse].sample_length(tick_sample_length), (tick_sample_length * 32).floor)
-    assert_equal(test_patterns[:staircase].sample_length(tick_sample_length), (tick_sample_length * 4).floor)
-  end
-
-  def test_tick_count
+  def test_step_count
     test_patterns = generate_test_data()
     
-    assert_equal(0,  test_patterns[:blank].tick_count())
-    assert_equal(32, test_patterns[:verse].tick_count())
-    assert_equal(4,  test_patterns[:staircase].tick_count())
+    assert_equal(0,  test_patterns[:blank].step_count())
+    assert_equal(32, test_patterns[:verse].step_count())
+    assert_equal(4,  test_patterns[:staircase].step_count())
   end
 
   def test_same_tracks_as?
     left_pattern = Pattern.new("left")
-    left_pattern.track("bass",      nil, "X...X...")
-    left_pattern.track("snare",     nil, "..X...X.")
-    left_pattern.track("hh_closed", nil, "X.X.X.X.")
+    left_pattern.track("bass",      "X...X...")
+    left_pattern.track("snare",     "..X...X.")
+    left_pattern.track("hh_closed", "X.X.X.X.")
     
     right_pattern = Pattern.new("right")
-    right_pattern.track("bass",      nil, "X...X...")
-    right_pattern.track("snare",     nil, "..X...X.")
-    right_pattern.track("hh_closed", nil, "X.X.X.X.")
+    right_pattern.track("bass",      "X...X...")
+    right_pattern.track("snare",     "..X...X.")
+    right_pattern.track("hh_closed", "X.X.X.X.")
     assert(left_pattern.same_tracks_as?(right_pattern))
     assert(right_pattern.same_tracks_as?(left_pattern))
     
     # Now switch up the order. Left and right should still be equal.
     right_pattern = Pattern.new("right")
-    right_pattern.track("snare",     nil, "..X...X.")
-    right_pattern.track("hh_closed", nil, "X.X.X.X.")
-    right_pattern.track("bass",      nil, "X...X...")
+    right_pattern.track("snare",     "..X...X.")
+    right_pattern.track("hh_closed", "X.X.X.X.")
+    right_pattern.track("bass",      "X...X...")
     assert(left_pattern.same_tracks_as?(right_pattern))
     assert(right_pattern.same_tracks_as?(left_pattern))
     
     # Now compare the pattern with same rhythms but different track names. Should not be equal.
     different_names_pattern = Pattern.new("different_names")
-    different_names_pattern.track("tom",     nil, "X...X...")
-    different_names_pattern.track("cymbal",  nil, "..X...X.")
-    different_names_pattern.track("hh_open", nil, "X.X.X.X.")
+    different_names_pattern.track("tom",     "X...X...")
+    different_names_pattern.track("cymbal",  "..X...X.")
+    different_names_pattern.track("hh_open", "X.X.X.X.")
     assert_equal(false, left_pattern.same_tracks_as?(different_names_pattern))
     assert_equal(false, different_names_pattern.same_tracks_as?(left_pattern))
     
     # Now compare the pattern with same track names but different rhythms. Should not be equal.
     different_beats_pattern = Pattern.new("different_beats")
-    different_beats_pattern.track("bass",      nil, "X...X...")
-    different_beats_pattern.track("snare",     nil, "..X...X.")
-    different_beats_pattern.track("hh_closed", nil, "X.XXX.X.")
+    different_beats_pattern.track("bass",      "X...X...")
+    different_beats_pattern.track("snare",     "..X...X.")
+    different_beats_pattern.track("hh_closed", "X.XXX.X.")
     assert_equal(false, left_pattern.same_tracks_as?(different_beats_pattern))
     assert_equal(false, different_beats_pattern.same_tracks_as?(left_pattern))
     
     # Now compare a pattern with the same tracks, but with one extra one as well. Should not be equal.
     something_extra = Pattern.new("something_extra")
-    something_extra.track("bass",      nil, "X...X...")
-    something_extra.track("snare",     nil, "..X...X.")
-    something_extra.track("hh_closed", nil, "X.X.X.X.")
-    something_extra.track("extra",     nil, "X..X..X.")
+    something_extra.track("bass",      "X...X...")
+    something_extra.track("snare",     "..X...X.")
+    something_extra.track("hh_closed", "X.X.X.X.")
+    something_extra.track("extra",     "X..X..X.")
     assert_equal(false, left_pattern.same_tracks_as?(something_extra))
     assert_equal(false, something_extra.same_tracks_as?(left_pattern))
   end
-  
-  def test_sample_data
-    tick_sample_lengths = [
-      13860.0,
-      (SAMPLE_RATE * SECONDS_IN_MINUTE) / 200 / 4,   # 3307.50
-      (SAMPLE_RATE * SECONDS_IN_MINUTE) / 99 / 4     # 6681.81818181818
-    ]
-
-    tick_sample_lengths.each{|tick_sample_length| helper_test_sample_data(tick_sample_length) }
-  end
-
-  def helper_test_sample_data(tick_sample_length)
-
-    test_patterns = generate_test_data()
-    
-    # Combined
-    test_patterns.each{|pattern_name, test_pattern|
-      sample_data = test_pattern.sample_data(tick_sample_length, 1, test_pattern.tracks.length, {})
-      assert_equal(sample_data.class, Hash)
-      assert_equal(sample_data.keys.map{|key| key.to_s}.sort, ["overflow", "primary"])
-      
-      primary_sample_length = test_pattern.sample_length(tick_sample_length)
-      full_sample_length = test_pattern.sample_length_with_overflow(tick_sample_length)
-      assert_equal(sample_data[:primary].length, primary_sample_length)
-      assert_equal(sample_data[:overflow].length, test_pattern.tracks.length)
-      sample_data[:overflow].values.each do |track_overflow|
-        assert_equal(track_overflow.class, Array)
-      end
-      # To do: add test to verify that longest overflow == full_sample_length - primary_sample_length
-    }
-  end
-  
-  def find_longest_overflow(overflow)
-    longest_overflow = overflow.keys.first
-    overflow.keys.each do |name|
-      if(overflow[name].length > overflow[longest_overflow].length)
-        longest_overflow = name
-      end
-    end
-    
-    return longest_overflow
-  end
-  
-  # Test scenario where incoming overflow for a track not in the pattern is longer than the pattern itself.
-  # In this situation, the the overflow should continue into the outgoing overflow so it is handled in the
-  # next pattern.
-  def test_sample_data_incoming_overflow_longer_than_pattern_length
-    # bass.wav sample length:   6179
-    # snare.wav sample length: 14700
-    kit = Kit.new("test/sounds")
-    kit.add("bass",  "bass_mono_8.wav")
-    kit.add("snare", "snare_mono_8.wav")
-    bass_sample_data = kit.get_sample_data("bass")
-    snare_sample_data = kit.get_sample_data("snare")
-    tick_sample_length = bass_sample_data.length.to_f
-    
-    # Construct expected
-    expected_primary_sample_data = Array.new(bass_sample_data.length)
-    bass_sample_data.length.times do |i|
-      expected_primary_sample_data[i] = ((bass_sample_data[i] + snare_sample_data[i]) / 2).round
-    end
-    expected_overflow_sample_data = snare_sample_data[bass_sample_data.length...snare_sample_data.length]
-    
-    # Get actual
-    pattern = Pattern.new :verse
-    pattern.track "bass", bass_sample_data, "X"
-    actual_sample_data = pattern.sample_data(tick_sample_length, 1, 2, {"snare" => snare_sample_data})
-    
-    assert_equal(Hash, actual_sample_data.class)
-    assert_equal(["overflow", "primary"], actual_sample_data.keys.map{|key| key.to_s}.sort)
-    assert_equal(expected_primary_sample_data, actual_sample_data[:primary])
-    assert_equal(["bass", "snare"], actual_sample_data[:overflow].keys.sort)
-    assert_equal([], actual_sample_data[:overflow]["bass"])
-    assert_equal(expected_overflow_sample_data, actual_sample_data[:overflow]["snare"])
-  end
-end
+end

data/test/patternexpander_test.rb

@@ -0,0 +1,142 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/includes'
+
+class PatternExpanderTest < Test::Unit::TestCase  
+  def test_expand_pattern_no_repeats
+    expected_pattern = Pattern.new :verse
+    expected_pattern.track "bass",  "X...X.X."
+    expected_pattern.track "snare", "....X..."
+        
+    # All of these should result in no expansion, since there are no repeats.
+    # In other words, the pattern shouldn't change.
+    # TODO: Add test for when flow is longer than longest track in pattern
+    ["", "|----|----|", "|----", "----:-:1"].each do |flow|
+      actual_pattern = Pattern.new :verse
+      actual_pattern.track "bass",  "|X...|X.X.|"
+      actual_pattern.track "snare", "|....|X...|"
+      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)
+      assert(expected_pattern.same_tracks_as?(actual_pattern))
+    end
+  end
+  
+  def test_expand_pattern_single_repeats
+    expected_pattern = Pattern.new :verse
+    expected_pattern.track "bass",  "X...X.X.X...X.X."
+    expected_pattern.track "snare", "....X.......X..."
+    
+    ["|----|---:|", "|----|---:2|", ":------:"].each do |flow|
+      actual_pattern = Pattern.new :verse
+      actual_pattern.track "bass",  "|X...|X.X.|"
+      actual_pattern.track "snare", "|....|X...|"
+      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)
+      assert(expected_pattern.same_tracks_as?(actual_pattern))
+    end
+    
+    
+    expected_pattern = Pattern.new :verse
+    expected_pattern.track "bass",  "X...X.X.X.X.X.X.X.X...X."
+    expected_pattern.track "snare", "....X...X...X...X...XXXX"
+    
+    ["|----|:-:4|----|"].each do |flow|
+      actual_pattern = Pattern.new :verse
+      actual_pattern.track "bass",  "|X...|X.X.|..X.|"
+      actual_pattern.track "snare", "|....|X...|XXXX|"
+      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)  
+      assert(expected_pattern.same_tracks_as?(actual_pattern))
+    end
+    
+    
+    # Zero repeats, so section gets removed from pattern
+    expected_pattern = Pattern.new :verse
+    expected_pattern.track "bass",  "X.....X."
+    expected_pattern.track "snare", "....XXXX"
+    
+    ["|----|:-:0|----|"].each do |flow|
+      actual_pattern = Pattern.new :verse
+      actual_pattern.track "bass",  "|X...|X.X.|..X.|"
+      actual_pattern.track "snare", "|....|X...|XXXX|"
+      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)  
+      assert(expected_pattern.same_tracks_as?(actual_pattern))
+    end
+  end
+  
+  def test_expand_pattern_multiple_repeats
+    expected_pattern = Pattern.new :verse
+    expected_pattern.track "bass",  "X...X...X.X.X.X."
+    expected_pattern.track "snare", "........X...X..."
+    
+    [":--::--:", ":-:2:--:", ":-:2:-:2"].each do |flow|
+      actual_pattern = Pattern.new :verse
+      actual_pattern.track "bass",  "|X...|X.X.|"
+      actual_pattern.track "snare", "|....|X...|"
+      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)
+      assert(expected_pattern.same_tracks_as?(actual_pattern))
+    end
+    
+    
+    expected_pattern = Pattern.new :verse
+    expected_pattern.track "bass",  "X...X.X.X.X.X.X..XXX..XX.."
+    expected_pattern.track "snare", "....X...X...X...X...XX..XX"
+    
+    ["----:-:3--:--:", "|----|:-:3|--|:-:2|"].each do |flow|
+      actual_pattern = Pattern.new :verse
+      actual_pattern.track "bass",  "|X...|X.X.|.X|XX..|"
+      actual_pattern.track "snare", "|....|X...|X.|..XX|"
+      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)
+      assert(expected_pattern.same_tracks_as?(actual_pattern))
+    end
+  end
+  
+  def test_expand_pattern_invalid
+    pattern = Pattern.new :verse
+    pattern.track "bass",  "|X...|X.X.|"
+    pattern.track "snare", "|....|X...|"
+    
+    # Patterns with an invalid character
+    ["a", "|---!---|", "|....|....|"].each do |invalid_flow|
+      assert_raise(InvalidFlowError) do
+        PatternExpander.expand_pattern(invalid_flow, pattern)
+      end
+    end
+    
+    ["----4:--", ":-:-:4-:", ":4-:-:-:"].each do |invalid_flow|
+      assert_raise(InvalidFlowError) do
+        PatternExpander.expand_pattern(invalid_flow, pattern)
+      end
+    end
+  end
+  
+  def test_valid_flow?
+    # Contains nothing but :, always valid
+    assert_equal(true, PatternExpander.valid_flow?(""))
+    assert_equal(true, PatternExpander.valid_flow?(":"))
+    assert_equal(true, PatternExpander.valid_flow?("::"))
+    assert_equal(true, PatternExpander.valid_flow?(":::"))
+    assert_equal(true, PatternExpander.valid_flow?("::::"))
+    assert_equal(true, PatternExpander.valid_flow?("|:--:|----|:--:|"))
+    
+    # Contains characters other than :|- and [0-9]
+    assert_equal(false, PatternExpander.valid_flow?("a"))
+    assert_equal(false, PatternExpander.valid_flow?("1"))
+    assert_equal(false, PatternExpander.valid_flow?(":--:z---"))
+    assert_equal(false, PatternExpander.valid_flow?(":   :"))
+    
+    assert_equal(true, PatternExpander.valid_flow?(":0"))
+    assert_equal(true, PatternExpander.valid_flow?(":1"))
+    assert_equal(true, PatternExpander.valid_flow?(":4"))
+    assert_equal(true, PatternExpander.valid_flow?(":4"))
+    assert_equal(true, PatternExpander.valid_flow?(":16"))
+    assert_equal(true, PatternExpander.valid_flow?("::4"))
+    assert_equal(true, PatternExpander.valid_flow?(":::4"))
+    assert_equal(true, PatternExpander.valid_flow?(":2::4"))
+    assert_equal(true, PatternExpander.valid_flow?("::2::4"))
+    
+    assert_equal(false, PatternExpander.valid_flow?(":4:"))
+    assert_equal(false, PatternExpander.valid_flow?("::4:"))
+    assert_equal(false, PatternExpander.valid_flow?(":4:4"))
+    assert_equal(false, PatternExpander.valid_flow?("::2:4"))
+    assert_equal(false, PatternExpander.valid_flow?("::2:"))
+    assert_equal(false, PatternExpander.valid_flow?("::2:::"))
+  end
+end

data/test/song_test.rb

@@ -3,42 +3,38 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 require 'test/includes'
 
 class SongTest < Test::Unit::TestCase
-  DEFAULT_TEMPO = 120
-  
+  FIXTURES = [:repeats_not_specified,
+              :pattern_with_overflow,
+              :example_no_kit,
+              :example_with_kit]
+
   def generate_test_data
-    kit = Kit.new("test/sounds")
-    kit.add("bass.wav",      "bass_mono_8.wav")
-    kit.add("snare.wav",     "snare_mono_8.wav")
-    kit.add("hh_closed.wav", "hh_closed_mono_8.wav")
-    kit.add("ride.wav",      "ride_mono_8.wav")
-    
     test_songs = {}
     base_path = File.dirname(__FILE__) + "/.."
 
-    test_songs[:blank] = Song.new(base_path)
-    
-    test_songs[:no_structure] = Song.new(base_path)
-    verse = test_songs[:no_structure].pattern :verse
-    verse.track "bass.wav",      kit.get_sample_data("bass.wav"),      "X.......X......."
-    verse.track "snare.wav",     kit.get_sample_data("snare.wav"),     "....X.......X..."
-    verse.track "hh_closed.wav", kit.get_sample_data("hh_closed.wav"), "X.X.X.X.X.X.X.X."
-    
-    test_songs[:repeats_not_specified] = SongParser.new().parse(base_path, YAML.load_file("test/fixtures/valid/repeats_not_specified.txt"))
-    test_songs[:overflow] = SongParser.new().parse(base_path, YAML.load_file("test/fixtures/valid/pattern_with_overflow.txt"))
-    test_songs[:from_valid_yaml_string] = SongParser.new().parse(base_path, YAML.load_file("test/fixtures/valid/example_no_kit.txt"))
-    test_songs[:from_valid_yaml_string_with_kit] = SongParser.new().parse(base_path, YAML.load_file("test/fixtures/valid/example_with_kit.txt"))
-    
-    test_songs[:from_code] = Song.new(base_path)
+    test_songs[:blank] = Song.new()
+    
+    test_songs[:no_flow] = Song.new()
+    verse = test_songs[:no_flow].pattern :verse
+    verse.track "bass.wav",      "X.......X......."
+    verse.track "snare.wav",     "....X.......X..."
+    verse.track "hh_closed.wav", "X.X.X.X.X.X.X.X."
+    
+    song_parser = SongParser.new()
+    FIXTURES.each do |fixture_name|
+      test_songs[fixture_name], throwaway_kit = song_parser.parse(base_path, File.read("test/fixtures/valid/#{fixture_name}.txt"))
+    end
+
+    test_songs[:from_code] = Song.new()
     verse = test_songs[:from_code].pattern :verse
-    verse.track "bass.wav",      kit.get_sample_data("bass.wav"),      "X.......X......."
-    verse.track "snare.wav",     kit.get_sample_data("snare.wav"),     "....X.......X..."
-    verse.track "hh_closed.wav", kit.get_sample_data("hh_closed.wav"), "X.X.X.X.X.X.X.X."
+    verse.track "bass.wav",      "X.......X......."
+    verse.track "snare.wav",     "....X.......X..."
+    verse.track "hh_closed.wav", "X.X.X.X.X.X.X.X."
     chorus = test_songs[:from_code].pattern :chorus
-    chorus.track "bass.wav",  kit.get_sample_data("bass.wav"),  "X......."
-    chorus.track "snare.wav", kit.get_sample_data("snare.wav"), "....X..X"
-    chorus.track "ride.wav",  kit.get_sample_data("ride.wav"),  "X.....X."
-    test_songs[:from_code].structure = [:verse, :chorus, :verse, :chorus, :chorus]
-    test_songs[:from_code].kit = kit
+    chorus.track "bass.wav",  "X......."
+    chorus.track "snare.wav", "....X..X"
+    chorus.track "ride.wav",  "X.....X."
+    test_songs[:from_code].flow = [:verse, :chorus, :verse, :chorus, :chorus]
     
     return test_songs
   end
@@ -46,119 +42,125 @@ class SongTest < Test::Unit::TestCase
   def test_initialize
     test_songs = generate_test_data()
     
-    assert_equal([], test_songs[:blank].structure)
-    assert_equal((Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0,
-                 test_songs[:blank].tick_sample_length)
-    
-    assert_equal([], test_songs[:no_structure].structure)
-    assert_equal((Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0,
-                 test_songs[:no_structure].tick_sample_length)
-    
-    assert_equal([:verse, :chorus, :verse, :chorus, :chorus], test_songs[:from_code].structure)
-    assert_equal((Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0,
-                 test_songs[:from_code].tick_sample_length)
+    assert_equal([], test_songs[:blank].flow)
+    assert_equal([], test_songs[:no_flow].flow)
+    assert_equal([:verse, :chorus, :verse, :chorus, :chorus], test_songs[:from_code].flow)
   end
   
   def test_total_tracks
     test_songs = generate_test_data()
     
     assert_equal(0, test_songs[:blank].total_tracks)
-    assert_equal(3, test_songs[:no_structure].total_tracks)
+    assert_equal(3, test_songs[:no_flow].total_tracks)
     assert_equal(3, test_songs[:from_code].total_tracks)
     assert_equal(1, test_songs[:repeats_not_specified].total_tracks)
-    assert_equal(1, test_songs[:overflow].total_tracks)
-    assert_equal(5, test_songs[:from_valid_yaml_string].total_tracks)
+    assert_equal(1, test_songs[:pattern_with_overflow].total_tracks)
+    assert_equal(5, test_songs[:example_no_kit].total_tracks)
+    assert_equal(5, test_songs[:example_with_kit].total_tracks)
   end
   
   def test_track_names
     test_songs = generate_test_data()
     
     assert_equal([], test_songs[:blank].track_names)
-    assert_equal(["bass.wav", "hh_closed.wav", "snare.wav"], test_songs[:no_structure].track_names)
+    assert_equal(["bass.wav", "hh_closed.wav", "snare.wav"], test_songs[:no_flow].track_names)
     assert_equal(["bass.wav", "hh_closed.wav", "ride.wav", "snare.wav"], test_songs[:from_code].track_names)
     assert_equal(["test/sounds/bass_mono_8.wav"], test_songs[:repeats_not_specified].track_names)
-    assert_equal(["test/sounds/snare_mono_8.wav"], test_songs[:overflow].track_names)
+    assert_equal(["test/sounds/snare_mono_8.wav"], test_songs[:pattern_with_overflow].track_names)
     assert_equal(["test/sounds/bass_mono_8.wav",
                   "test/sounds/hh_closed_mono_8.wav",
                   "test/sounds/hh_open_mono_8.wav",
                   "test/sounds/ride_mono_8.wav",
                   "test/sounds/snare_mono_8.wav"],
-                  test_songs[:from_valid_yaml_string].track_names)
+                  test_songs[:example_no_kit].track_names)
+    assert_equal(["bass",
+                  "hhclosed",
+                  "hhopen",
+                  "snare",
+                  "test/sounds/hh_closed_mono_8.wav",
+                  "test/sounds/ride_mono_8.wav"],
+                  test_songs[:example_with_kit].track_names)
   end
   
-  def test_sample_length
+  def test_copy_ignoring_patterns_and_flow
     test_songs = generate_test_data()
-
-    assert_equal(0, test_songs[:blank].sample_length)
-    assert_equal(0, test_songs[:no_structure].sample_length)
+    original_song = test_songs[:example_no_kit]
+    cloned_song = original_song.copy_ignoring_patterns_and_flow()
     
-    assert_equal((test_songs[:from_code].tick_sample_length * 16 * 2) +
-                     (test_songs[:from_code].tick_sample_length * 8 * 3),
-                 test_songs[:from_code].sample_length)
-                            
-    assert_equal(test_songs[:repeats_not_specified].tick_sample_length,
-                 test_songs[:repeats_not_specified].sample_length)
-                            
-    assert_equal(test_songs[:overflow].tick_sample_length * 8, test_songs[:overflow].sample_length)
+    assert_not_equal(cloned_song, original_song)
+    assert_equal(cloned_song.tempo, original_song.tempo)
+    assert_equal([], cloned_song.flow)
+    assert_equal({}, cloned_song.patterns)
   end
   
-  def test_sample_length_with_overflow
+  def test_remove_patterns_except
+    # Remove an existing pattern.
     test_songs = generate_test_data()
-    
-    assert_equal(0, test_songs[:blank].sample_length_with_overflow)
-    assert_equal(0, test_songs[:no_structure].sample_length_with_overflow)
-    
-    snare_overflow =
-      (test_songs[:from_code].kit.get_sample_data("snare.wav").length -
-       test_songs[:from_code].tick_sample_length).ceil   
-    assert_equal(test_songs[:from_code].sample_length + snare_overflow, test_songs[:from_code].sample_length_with_overflow)    
-    
-    assert_equal(test_songs[:repeats_not_specified].tick_sample_length,
-                 test_songs[:repeats_not_specified].sample_length_with_overflow)
-    
-    snare_overflow =
-      (test_songs[:overflow].kit.get_sample_data("test/sounds/snare_mono_8.wav").length -
-       test_songs[:overflow].tick_sample_length).ceil
-    assert_equal((test_songs[:overflow].tick_sample_length * 8) + snare_overflow,
-                 test_songs[:overflow].sample_length_with_overflow)
-    
-    snare_overflow =
-      (test_songs[:from_valid_yaml_string].kit.get_sample_data("test/sounds/snare_mono_8.wav").length -
-       test_songs[:from_valid_yaml_string].tick_sample_length).ceil
-    assert_equal(test_songs[:from_valid_yaml_string].sample_length + snare_overflow,
-                 test_songs[:from_valid_yaml_string].sample_length_with_overflow)
+    test_songs[:example_with_kit].remove_patterns_except(:chorus)
+    assert_equal([:chorus], test_songs[:example_with_kit].flow)
+    assert_equal([:chorus], test_songs[:example_with_kit].patterns.keys)
+
+    # Try to remove a non-existent pattern. Error city.
+    test_songs = generate_test_data()
+    assert_raise(StandardError) do
+      test_songs[:example_with_kit].remove_patterns_except(:iamnotapattern)
+    end
   end
-  
-  def test_copy_ignoring_patterns_and_structure
+
+  def test_split
     test_songs = generate_test_data()
-    original_song = test_songs[:from_valid_yaml_string]
-    cloned_song = original_song.copy_ignoring_patterns_and_structure()
+    split_songs = test_songs[:example_with_kit].split()
     
-    assert_not_equal(cloned_song, original_song)
-    assert_equal(cloned_song.tempo, original_song.tempo)
-    assert_equal(cloned_song.kit, original_song.kit)
-    assert_equal(cloned_song.tick_sample_length, original_song.tick_sample_length)
-    assert_equal([], cloned_song.structure)
-    assert_equal({}, cloned_song.patterns)
+    assert_equal(Hash, split_songs.class)
+    assert_equal(6, split_songs.length)
+    
+    song_names = split_songs.keys.sort
+    assert_equal(["bass",
+                  "hhclosed",
+                  "hhopen",
+                  "snare",
+                  "test/sounds/hh_closed_mono_8.wav",
+                  "test/sounds/ride_mono_8.wav"],
+                 song_names)
+                 
+    song_names.each do |song_name|
+      song = split_songs[song_name]
+      assert_equal(99, song.tempo)
+      assert_equal(3, song.patterns.length)
+      assert_equal([:verse, :verse, :chorus, :chorus, :verse, :verse, :chorus, :chorus, :chorus, :chorus,
+                    :bridge, :chorus, :chorus, :chorus, :chorus],
+                   song.flow)
+                   
+      song.patterns.each do |pattern_name, pattern|
+        assert_equal(1, pattern.tracks.length)
+        assert_equal([song_name], pattern.tracks.keys)
+        assert_equal(song_name, pattern.tracks[song_name].name)
+      end
+    end
   end
   
   def test_remove_unused_patterns
     test_songs = generate_test_data()
     
-    assert_equal(1, test_songs[:no_structure].patterns.length)
-    test_songs[:no_structure].remove_unused_patterns()
-    assert_equal({}, test_songs[:no_structure].patterns)
+    assert_equal(1, test_songs[:no_flow].patterns.length)
+    test_songs[:no_flow].remove_unused_patterns()
+    assert_equal({}, test_songs[:no_flow].patterns)
     
-    assert_equal(3, test_songs[:from_valid_yaml_string].patterns.length)
-    test_songs[:from_valid_yaml_string].remove_unused_patterns()
-    assert_equal(3, test_songs[:from_valid_yaml_string].patterns.length)
-    assert_equal(Hash, test_songs[:from_valid_yaml_string].patterns.class)
+    assert_equal(3, test_songs[:example_no_kit].patterns.length)
+    test_songs[:example_no_kit].remove_unused_patterns()
+    assert_equal(3, test_songs[:example_no_kit].patterns.length)
+    assert_equal(Hash, test_songs[:example_no_kit].patterns.class)
   end
   
   def test_to_yaml
     test_songs = generate_test_data()
-    result = test_songs[:from_valid_yaml_string_with_kit].to_yaml
+    kit = Kit.new("test/sounds", {"bass"     => "bass_mono_8.wav",
+                                  "snare"    => "snare_mono_8.wav",
+                                  "hhclosed" => "hh_closed_mono_8.wav",
+                                  "hhopen"   => "hh_open_mono_8.wav"})
+
+    result = test_songs[:example_with_kit].to_yaml(kit)
     
     assert_equal(File.read("test/fixtures/yaml/song_yaml.txt"), result)
   end
-end
+end