beats 1.2.0 → 1.2.1

data/test/songoptimizer_test.rb

@@ -3,16 +3,18 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 require 'test/includes'
 
 class MockSongOptimizer < SongOptimizer
-  def clone_song_ignoring_patterns_and_structure(original_song)
+  def clone_song_ignoring_patterns_and_flow(original_song)
     return super
   end
 end
 
 class SongOptimizerTest < Test::Unit::TestCase
+  FIXTURE_BASE_PATH = File.dirname(__FILE__) + "/.."
+
   EXAMPLE_SONG_YAML = "
 Song:
   Tempo: 135
-  Structure:
+  Flow:
     - Verse:   x2
     - Chorus:  x4
     - Verse:   x2
@@ -39,7 +41,7 @@ Chorus:
   EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN = "
 Song:
   Tempo: 135
-  Structure:
+  Flow:
     - Verse:   x1
   Kit:
     - bass:   sounds/bass.wav
@@ -49,114 +51,126 @@ Verse:
   - bass:   X.......X...
   - snare:  ..........X."
 
+  def self.load_fixture(fixture_name)
+    return SongParser.new().parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
+  end
+
   def test_optimize
     parser = SongParser.new()
-    original_song = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML)
+    original_song, kit = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML)
     
     optimizer = SongOptimizer.new()
     optimized_song = optimizer.optimize(original_song, 4)
     
     assert_equal(optimized_song.tempo, 135)
     #assert_equal(optimized_song.total_tracks, 5)
-    assert_equal(original_song.kit, optimized_song.kit)
-    assert_equal(original_song.sample_length, optimized_song.sample_length)
-    assert_equal(original_song.sample_length_with_overflow, optimized_song.sample_length_with_overflow)
+
+    # TODO: Add some sort of AudioEngine test to verify that optimized and unoptimized song have same sample data.
+    #assert_equal(original_song.sample_length, optimized_song.sample_length)
+    #assert_equal(original_song.sample_length_with_overflow, optimized_song.sample_length_with_overflow)
     #assert_equal(original_song.sample_data(false), optimized_song.sample_data(false))
     
-    # Patterns :verse0 and :verse4 should be removed since they are identical to :chorus0
-    assert_equal([:chorus0, :chorus12, :chorus4, :chorus8, :verse12, :verse8],
+    # Patterns :verse_0 and :verse_4 should be removed since they are identical to :chorus_0
+    assert_equal([:chorus_0, :chorus_12, :chorus_4, :chorus_8, :verse_12, :verse_8],
                  optimized_song.patterns.keys.sort {|x, y| x.to_s <=> y.to_s })
         
-    pattern = optimized_song.patterns[:verse8]
+    pattern = optimized_song.patterns[:verse_8]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.X.")
     
-    pattern = optimized_song.patterns[:verse12]
+    pattern = optimized_song.patterns[:verse_12]
     assert_equal(pattern.tracks.keys.sort, ["agogo", "bass", "hh_closed", "snare"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["snare"].rhythm, "..X.")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.X.")
     assert_equal(pattern.tracks["agogo"].rhythm, "..XX")
     
-    pattern = optimized_song.patterns[:chorus0]
+    pattern = optimized_song.patterns[:chorus_0]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.XX")
     
-    pattern = optimized_song.patterns[:chorus4]
+    pattern = optimized_song.patterns[:chorus_4]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed", "snare"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["snare"].rhythm, "X...")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.XX")
     
-    pattern = optimized_song.patterns[:chorus8]
+    pattern = optimized_song.patterns[:chorus_8]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed", "sounds/tom4.wav"])
     assert_equal(pattern.tracks["bass"].rhythm, "XX..")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.XX")
     assert_equal(pattern.tracks["sounds/tom4.wav"].rhythm, "...X")
     
-    pattern = optimized_song.patterns[:chorus12]
+    pattern = optimized_song.patterns[:chorus_12]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed", "snare", "sounds/tom2.wav"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["snare"].rhythm, "X...")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "..X.")
     assert_equal(pattern.tracks["sounds/tom2.wav"].rhythm, "..X.")
     
-    assert_equal(optimized_song.structure, [:chorus0, :chorus0, :verse8, :verse12,
-                                            :chorus0, :chorus0, :verse8, :verse12,
-                                            :chorus0, :chorus4, :chorus8, :chorus12,
-                                            :chorus0, :chorus4, :chorus8, :chorus12,
-                                            :chorus0, :chorus4, :chorus8, :chorus12,
-                                            :chorus0, :chorus4, :chorus8, :chorus12,
-                                            :chorus0, :chorus0, :verse8, :verse12,
-                                            :chorus0, :chorus0, :verse8, :verse12,
-                                            :chorus0, :chorus4, :chorus8, :chorus12,
-                                            :chorus0, :chorus4, :chorus8, :chorus12,
-                                            :chorus0, :chorus4, :chorus8, :chorus12,
-                                            :chorus0, :chorus4, :chorus8, :chorus12])
+    assert_equal(optimized_song.flow, [:chorus_0, :chorus_0, :verse_8, :verse_12,
+                                       :chorus_0, :chorus_0, :verse_8, :verse_12,
+                                       :chorus_0, :chorus_4, :chorus_8, :chorus_12,
+                                       :chorus_0, :chorus_4, :chorus_8, :chorus_12,
+                                       :chorus_0, :chorus_4, :chorus_8, :chorus_12,
+                                       :chorus_0, :chorus_4, :chorus_8, :chorus_12,
+                                       :chorus_0, :chorus_0, :verse_8, :verse_12,
+                                       :chorus_0, :chorus_0, :verse_8, :verse_12,
+                                       :chorus_0, :chorus_4, :chorus_8, :chorus_12,
+                                       :chorus_0, :chorus_4, :chorus_8, :chorus_12,
+                                       :chorus_0, :chorus_4, :chorus_8, :chorus_12,
+                                       :chorus_0, :chorus_4, :chorus_8, :chorus_12])
   end
   
   def test_optimize_song_nondivisible_max_pattern_length()
     parser = SongParser.new()
-    original_song = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
+    original_song, kit = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
     
     optimizer = SongOptimizer.new()
     optimized_song = optimizer.optimize(original_song, 7)
     
-    pattern = optimized_song.patterns[:verse0]
+    pattern = optimized_song.patterns[:verse_0]
     assert_equal(["bass"], pattern.tracks.keys.sort)
     assert_equal("X......", pattern.tracks["bass"].rhythm)
     
-    pattern = optimized_song.patterns[:verse7]
+    pattern = optimized_song.patterns[:verse_7]
     assert_equal(["bass", "snare"], pattern.tracks.keys.sort)
     assert_equal(".X...", pattern.tracks["bass"].rhythm)
     assert_equal("...X.", pattern.tracks["snare"].rhythm)
     
-    assert_equal([:verse0, :verse7], optimized_song.structure)
+    assert_equal([:verse_0, :verse_7], optimized_song.flow)
   end
   
+  def test_pattern_collision
+    original_song, kit = SongOptimizerTest.load_fixture("valid/optimize_pattern_collision.txt")
+    optimizer = SongOptimizer.new()
+    optimized_song = optimizer.optimize(original_song, 4)
+  
+    assert_equal([:verse2_0, :verse_0, :verse_20], optimized_song.patterns.keys.sort {|x, y| x.to_s <=> y.to_s })
+  end
+
   def test_optimize_song_containing_empty_pattern()
     parser = SongParser.new()
-    original_song = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
+    original_song, kit = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
     
     optimizer = SongOptimizer.new()
     optimized_song = optimizer.optimize(original_song, 4)
     
-    pattern = optimized_song.patterns[:verse0]
+    pattern = optimized_song.patterns[:verse_0]
     assert_equal(["bass"], pattern.tracks.keys.sort)
     assert_equal("X...", pattern.tracks["bass"].rhythm)
     
-    pattern = optimized_song.patterns[:verse4]
+    pattern = optimized_song.patterns[:verse_4]
     assert_equal(["placeholder"], pattern.tracks.keys.sort)
     assert_equal("....", pattern.tracks["placeholder"].rhythm)
-    assert_equal([], pattern.tracks["placeholder"].wave_data)
     
-    pattern = optimized_song.patterns[:verse8]
+    pattern = optimized_song.patterns[:verse_8]
     assert_equal(["bass", "snare"], pattern.tracks.keys.sort)
     assert_equal("X...", pattern.tracks["bass"].rhythm)
     assert_equal("..X.", pattern.tracks["snare"].rhythm)
     
-    assert_equal([:verse0, :verse4, :verse8], optimized_song.structure)
+    assert_equal([:verse_0, :verse_4, :verse_8], optimized_song.flow)
   end
-end
+end

data/test/songparser_test.rb

@@ -2,77 +2,110 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
 require 'test/includes'
 
-class SongParserTest < Test::Unit::TestCase  
-  def self.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")
+class SongParserTest < Test::Unit::TestCase
+  FIXTURE_BASE_PATH = File.dirname(__FILE__) + "/.."
 
-    test_songs = {}
-    base_path = File.dirname(__FILE__) + "/.."
+  # TODO: Add fixture for track with no rhythm
+  VALID_FIXTURES =   [:no_tempo,
+                      :repeats_not_specified,
+                      :pattern_with_overflow,
+                      :example_no_kit,
+                      :example_with_kit,
+                      :example_with_empty_track,
+                      :multiple_tracks_same_sound,
+                      :with_structure]
+  
+  INVALID_FIXTURES = [:bad_repeat_count,
+                      :bad_flow,
+                      :bad_tempo,
+                      :no_header,
+                      :no_flow,
+                      :pattern_with_no_tracks,
+                      :sound_in_kit_not_found,
+                      :sound_in_track_not_found,
+                      :sound_in_kit_wrong_format,
+                      :sound_in_track_wrong_format]
 
-    test_songs[:no_tempo] = SongParser.new().parse(base_path, YAML.load_file("test/fixtures/valid/no_tempo.txt"))
-    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"))
-    # TODO: Add fixture for track with no rhythm
-    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_valid_yaml_string_with_empty_track] = SongParser.new().parse(base_path, YAML.load_file("test/fixtures/valid/example_with_empty_track.txt"))
+  def self.load_fixture(fixture_name)
+    return SongParser.new().parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
+  end
+
+  def self.generate_test_data
+    test_songs = {}
+    test_kits = {}
 
-    return test_songs
+    VALID_FIXTURES.each do |fixture_name|
+      song, kit = load_fixture("valid/#{fixture_name}.txt")
+      test_songs[fixture_name] = song
+      test_kits[fixture_name] = kit
+    end
+    
+    return test_songs, test_kits
   end
 
+  # TODO: Add somes tests to validate the Kits
   def test_valid_parse
-    test_songs = SongParserTest.generate_test_data()
+    test_songs, test_kits = SongParserTest.generate_test_data()
     
-    assert_equal(test_songs[:no_tempo].tempo, 120)
-    assert_equal(test_songs[:no_tempo].structure, [:verse])
+    assert_equal(120, test_songs[:no_tempo].tempo)
+    assert_equal([:verse], test_songs[:no_tempo].flow)
     
-    assert_equal(test_songs[:repeats_not_specified].tempo, 100)
-    assert_equal(test_songs[:repeats_not_specified].structure, [:verse])
+    assert_equal(100, test_songs[:repeats_not_specified].tempo)
+    assert_equal([:verse], test_songs[:repeats_not_specified].flow)
     
     # These two songs should be the same, except that one uses a kit in the song header
     # and the other doesn't.
-    [:from_valid_yaml_string, :from_valid_yaml_string_with_kit].each do |song_key|
+    [:example_no_kit, :example_with_kit].each do |song_key|
       song = test_songs[song_key]
-      assert_equal(song.structure, [:verse, :verse, :chorus, :chorus, :verse, :verse, :chorus, :chorus, :chorus, :chorus, :bridge, :chorus, :chorus, :chorus, :chorus])
-      assert_equal(song.tempo, 99)
-      assert_equal(song.tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / 99 / 4.0)
-      assert_equal(song.patterns.keys.map{|key| key.to_s}.sort, ["bridge", "chorus", "verse"])
-      assert_equal(song.patterns[:verse].tracks.length, 4)
-      assert_equal(song.patterns[:chorus].tracks.length, 5)
-      assert_equal(song.patterns[:bridge].tracks.length, 1)
+      assert_equal([:verse, :verse,
+                    :chorus, :chorus,
+                    :verse, :verse,
+                    :chorus, :chorus, :chorus, :chorus,
+                    :bridge,
+                    :chorus, :chorus, :chorus, :chorus],
+                   song.flow)
+      assert_equal(99, song.tempo)
+      assert_equal(["bridge", "chorus", "verse"], song.patterns.keys.map{|key| key.to_s}.sort)
+      assert_equal(4, song.patterns[:verse].tracks.length)
+      assert_equal(5, song.patterns[:chorus].tracks.length)
+      assert_equal(1, song.patterns[:bridge].tracks.length)
     end
     
-    song = test_songs[:from_valid_yaml_string_with_empty_track]
+    song = test_songs[:example_with_empty_track]
     assert_equal(1, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
     assert_equal("........", song.patterns[:verse].tracks["test/sounds/bass_mono_8.wav"].rhythm)
     assert_equal("X...X...", song.patterns[:verse].tracks["test/sounds/snare_mono_8.wav"].rhythm)
+    
+    song = test_songs[:multiple_tracks_same_sound]
+    assert_equal(2, song.patterns.length)
+    assert_equal(7, song.patterns[:verse].tracks.length)
+    assert_equal(["agogo", "bass", "bass2", "bass3", "bass4", "hh_closed", "snare"],
+                 song.patterns[:verse].tracks.keys.sort)
+    assert_equal("X...............", song.patterns[:verse].tracks["bass"].rhythm)
+    assert_equal("....X...........", song.patterns[:verse].tracks["bass2"].rhythm)
+    assert_equal("........X.......", song.patterns[:verse].tracks["bass3"].rhythm)
+    assert_equal("............X...", song.patterns[:verse].tracks["bass4"].rhythm)
+    assert_equal("..............X.", song.patterns[:verse].tracks["snare"].rhythm)
+    assert_equal("X.XXX.XXX.X.X.X.", song.patterns[:verse].tracks["hh_closed"].rhythm)
+    assert_equal("..............XX", song.patterns[:verse].tracks["agogo"].rhythm)
+  
+    song = test_songs[:with_structure]
+    assert_equal([:verse, :verse], song.flow)
+    assert_equal(1, song.patterns.length)
+    assert_equal(1, song.patterns[:verse].tracks.length)
+    assert_equal("X...X...", song.patterns[:verse].tracks["test/sounds/bass_mono_8.wav"].rhythm)
   end
   
   def test_invalid_parse
-    invalid_fixtures = ["bad_repeat_count",
-                        "bad_structure",
-                        "bad_tempo",
-                        "no_header",
-                        "no_structure",
-                        "pattern_with_no_tracks",
-                        "sound_in_track_not_found",
-                        "sound_in_kit_not_found",]
-    
-    invalid_fixtures.each do |fixture|
+    INVALID_FIXTURES.each do |fixture|
       assert_raise(SongParseError) do
-        song = SongParser.new().parse(File.dirname(__FILE__) + "/..",
-                                      YAML.load_file("test/fixtures/invalid/" + fixture + ".txt"))
+        song = SongParserTest.load_fixture("invalid/#{fixture}.txt")
       end
     end
     
     assert_raise(InvalidRhythmError) do
-      song = SongParser.new().parse(File.dirname(__FILE__) + "/..",
-                                    YAML.load_file("test/fixtures/invalid/bad_rhythm.txt"))
+      song = SongParserTest.load_fixture("invalid/bad_rhythm.txt")
     end
   end
-end
+end

data/test/track_test.rb

@@ -2,24 +2,16 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
 require 'test/includes'
 
-class MockTrack < Track
-  attr_reader :beats
-end
-
 class TrackTest < Test::Unit::TestCase
-  SECONDS_IN_MINUTE = 60.0
-  SOUND_FILE_PATH = "test/sounds/bass_mono_8.wav"
-  W = WaveFile.open(SOUND_FILE_PATH)
-  
   def generate_test_data
-    test_tracks = []
+    test_tracks = {}
     
-    test_tracks << MockTrack.new("bass", W.sample_data, "")
-    test_tracks << MockTrack.new("bass", W.sample_data, "X")
-    test_tracks << MockTrack.new("bass", W.sample_data, "...X")
-    test_tracks << MockTrack.new("bass", W.sample_data, "X.X.X.X.")
-    test_tracks << MockTrack.new("bass", W.sample_data, "....")
-    test_tracks << MockTrack.new("bass", W.sample_data, "..X...X...X...X.X...X...X...X...")
+    test_tracks[:blank] = Track.new("bass", "")
+    test_tracks[:solo] = Track.new("bass", "X")
+    test_tracks[:with_overflow] = Track.new("bass", "...X")
+    test_tracks[:with_barlines] = Track.new("bass", "|X.X.|X.X.|")
+    test_tracks[:placeholder] = Track.new("bass", "....")
+    test_tracks[:complicated] = Track.new("bass", "..X...X...X...X.X...X...X...X...")
     
     return test_tracks
   end
@@ -27,183 +19,36 @@ class TrackTest < Test::Unit::TestCase
   def test_initialize
     test_tracks = generate_test_data()
     
-    assert_equal([0], test_tracks[0].beats)
-    assert_equal("bass", test_tracks[0].name)
+    assert_equal([0], test_tracks[:blank].beats)
+    assert_equal("bass", test_tracks[:blank].name)
+    assert_equal("", test_tracks[:blank].rhythm)
     
-    assert_equal([0, 1], test_tracks[1].beats)
-    assert_equal("bass", test_tracks[1].name)
+    assert_equal([0, 1], test_tracks[:solo].beats)
+    assert_equal("bass", test_tracks[:solo].name)
+    assert_equal("X", test_tracks[:solo].rhythm)
     
-    assert_equal([3, 1], test_tracks[2].beats)
-    assert_equal([0, 2, 2, 2, 2], test_tracks[3].beats)
-    assert_equal([4], test_tracks[4].beats)
-    assert_equal([2, 4, 4, 4, 2, 4, 4, 4, 4], test_tracks[5].beats)
-  end
-  
-  def test_tick_count
-    test_tracks = generate_test_data()
+    assert_equal([3, 1], test_tracks[:with_overflow].beats)
+    assert_equal("...X", test_tracks[:with_overflow].rhythm)
     
-    assert_equal(0,  test_tracks[0].tick_count())
-    assert_equal(1,  test_tracks[1].tick_count())
-    assert_equal(4,  test_tracks[2].tick_count())
-    assert_equal(8,  test_tracks[3].tick_count())
-    assert_equal(4,  test_tracks[4].tick_count())
-    assert_equal(32, test_tracks[5].tick_count())
-  end
-
-  def test_intro_sample_length
-    # TODO: Add tests for when tick_sample_length has a non-zero remainder
+    assert_equal([0, 2, 2, 2, 2], test_tracks[:with_barlines].beats)
+    # Bar lines should be removed from rhythm:
+    assert_equal("X.X.X.X.", test_tracks[:with_barlines].rhythm)
     
-    test_tracks = generate_test_data()
-
-    tick_sample_length = W.sample_data.length        # 6179.0
-    assert_equal(0,     test_tracks[0].intro_sample_length(tick_sample_length))
-    assert_equal(0,     test_tracks[1].intro_sample_length(tick_sample_length))
-    assert_equal(18537, test_tracks[2].intro_sample_length(tick_sample_length))
-    assert_equal(0,     test_tracks[3].intro_sample_length(tick_sample_length))
-    assert_equal(24716, test_tracks[4].intro_sample_length(tick_sample_length))
-    assert_equal(12358, test_tracks[5].intro_sample_length(tick_sample_length))
-  end
-
-  def test_sample_length
-    tick_sample_lengths = [
-      W.sample_data.length,                           # 13860.0 - FIXME, not correct
-      (W.sample_rate * SECONDS_IN_MINUTE) / 99 / 4,   # 6681.81818181818 - FIXME, not correct
-      (W.sample_rate * SECONDS_IN_MINUTE) / 41 / 4    # 16134.1463414634 - FIXME, not correct
-    ]
-
-    tick_sample_lengths.each {|tick_sample_length| helper_test_sample_length(tick_sample_length) }
-  end
-
-  def helper_test_sample_length(tick_sample_length)
-    test_tracks = generate_test_data()
-    
-    assert_equal(0, test_tracks[0].sample_length(tick_sample_length))
-    assert_equal(test_tracks[0].sample_data(tick_sample_length)[:primary].length, test_tracks[0].sample_length(tick_sample_length))
-    
-    assert_equal(tick_sample_length.floor, test_tracks[1].sample_length(tick_sample_length))
-    assert_equal(test_tracks[1].sample_data(tick_sample_length)[:primary].length, test_tracks[1].sample_length(tick_sample_length))
+    assert_equal([4], test_tracks[:placeholder].beats)
+    assert_equal("....", test_tracks[:placeholder].rhythm)
     
-    assert_equal((tick_sample_length * 4).floor, test_tracks[2].sample_length(tick_sample_length))
-    assert_equal(test_tracks[2].sample_data(tick_sample_length)[:primary].length, test_tracks[2].sample_length(tick_sample_length))
-    
-    assert_equal((tick_sample_length * 8).floor, test_tracks[3].sample_length(tick_sample_length))
-    assert_equal(test_tracks[3].sample_data(tick_sample_length)[:primary].length, test_tracks[3].sample_length(tick_sample_length))
-    
-    assert_equal((tick_sample_length * 4).floor, test_tracks[4].sample_length(tick_sample_length))
-    assert_equal(test_tracks[4].sample_data(tick_sample_length)[:primary].length, test_tracks[4].sample_length(tick_sample_length))
-    
-    assert_equal((tick_sample_length * 32).floor, test_tracks[5].sample_length(tick_sample_length))
-    assert_equal(test_tracks[5].sample_data(tick_sample_length)[:primary].length, test_tracks[5].sample_length(tick_sample_length))
+    assert_equal([2, 4, 4, 4, 2, 4, 4, 4, 4], test_tracks[:complicated].beats)
+    assert_equal("..X...X...X...X.X...X...X...X...", test_tracks[:complicated].rhythm)
   end
   
-  def test_sample_length_with_overflow
-    tick_sample_lengths = [
-      W.sample_data.length,                           # 13860.0 - FIXME, not correct
-      (W.sample_rate * SECONDS_IN_MINUTE) / 99 / 4,   # 6681.81818181818 - FIXME, not correct
-      (W.sample_rate * SECONDS_IN_MINUTE) / 41 / 4    # 16134.1463414634 - FIXME, not correct
-    ]
-
-    tick_sample_lengths.each { |tick_sample_length| helper_test_sample_length_with_overflow(tick_sample_length) }
-  end
-  
-  def helper_test_sample_length_with_overflow(tick_sample_length)
-    wave_sample_length = W.sample_data.length
-    test_tracks = generate_test_data()
-    
-    sample_data = test_tracks[0].sample_data(tick_sample_length)
-    assert_equal(0, test_tracks[0].sample_length_with_overflow(tick_sample_length))
-    assert_equal(sample_data[:primary].length + sample_data[:overflow].length, test_tracks[0].sample_length_with_overflow(tick_sample_length))
-    
-    sample_data = test_tracks[1].sample_data(tick_sample_length)
-    if(wave_sample_length > tick_sample_length * test_tracks[1].beats.last)
-      assert_equal(wave_sample_length, test_tracks[1].sample_length_with_overflow(tick_sample_length))
-    else
-      assert_equal(tick_sample_length.floor, test_tracks[1].sample_length_with_overflow(tick_sample_length))
-      assert_equal(sample_data[:primary].length + sample_data[:overflow].length, test_tracks[1].sample_length_with_overflow(tick_sample_length))
-    end
-    
-    sample_data = test_tracks[2].sample_data(tick_sample_length)
-    if(wave_sample_length > tick_sample_length * test_tracks[2].beats.last)
-      assert_equal((tick_sample_length * 4).floor + (wave_sample_length - tick_sample_length.floor), test_tracks[2].sample_length_with_overflow(tick_sample_length))
-      assert_equal(sample_data[:primary].length + sample_data[:overflow].length, test_tracks[2].sample_length_with_overflow(tick_sample_length))
-    else
-      assert_equal((tick_sample_length * 4).floor, test_tracks[2].sample_length_with_overflow(tick_sample_length))
-      assert_equal(sample_data[:primary].length + sample_data[:overflow].length, test_tracks[2].sample_length_with_overflow(tick_sample_length))
-    end
-    
-    sample_data = test_tracks[3].sample_data(tick_sample_length)
-    if(wave_sample_length > tick_sample_length * test_tracks[3].beats.last)
-      assert_equal((tick_sample_length * 8).floor + (wave_sample_length - (tick_sample_length * 2).floor), test_tracks[3].sample_length_with_overflow(tick_sample_length))
-      assert_equal(sample_data[:primary].length + sample_data[:overflow].length, test_tracks[3].sample_length_with_overflow(tick_sample_length))
-    else
-      assert_equal((tick_sample_length * 8).floor, test_tracks[3].sample_length_with_overflow(tick_sample_length))
-      assert_equal(sample_data[:primary].length + sample_data[:overflow].length, test_tracks[3].sample_length_with_overflow(tick_sample_length))
-    end
-    
-    sample_data = test_tracks[4].sample_data(tick_sample_length)
-    assert_equal((tick_sample_length * 4).floor, test_tracks[4].sample_length_with_overflow(tick_sample_length))
-    assert_equal(sample_data[:primary].length + sample_data[:overflow].length, test_tracks[4].sample_length_with_overflow(tick_sample_length))
-    
-    sample_data = test_tracks[5].sample_data(tick_sample_length)
-    assert_equal((tick_sample_length * 32).floor, test_tracks[5].sample_length_with_overflow(tick_sample_length))
-    assert_equal(sample_data[:primary].length + sample_data[:overflow].length, test_tracks[5].sample_length_with_overflow(tick_sample_length))
-  end
-    
-  def test_sample_data
-    sample_data = W.sample_data
-    
-    tick_sample_length = W.sample_data.length   # 6179.0
+  def test_step_count
     test_tracks = generate_test_data()
-    assert_equal({:primary => [], :overflow => []}, test_tracks[0].sample_data(tick_sample_length))
-    helper_test_sample_data(test_tracks[1], tick_sample_length, sample_data[0...tick_sample_length], [])
-    helper_test_sample_data(test_tracks[2], tick_sample_length, zeroes(tick_sample_length * 3) + sample_data, [])
-    helper_test_sample_data(test_tracks[3], tick_sample_length, (sample_data + zeroes(tick_sample_length)) * 4, [])
-    helper_test_sample_data(test_tracks[4], tick_sample_length, zeroes(tick_sample_length * 4), [])
-    # Track 6 is complicated. Will add test later...
-
-
-    tick_sample_length = (W.sample_rate * 60.0) / 220 / 4   # 3006.818181818181818
-    test_tracks = generate_test_data()
-    assert_equal({:primary => [], :overflow => []}, test_tracks[0].sample_data(tick_sample_length))
-    helper_test_sample_data(test_tracks[1], tick_sample_length, sample_data[0...tick_sample_length.floor], sample_data[tick_sample_length.floor...sample_data.length])
-    #helper_test_sample_data(test_tracks[2], tick_sample_length, zeroes(tick_sample_length * 3) + sample_data[0..tick_sample_length.floor], sample_data[(tick_sample_length.floor)...sample_data.length])
-    #helper_test_sample_data(test_tracks[3], tick_sample_length,
-    #                        sample_data[0...(tick_sample_length * 2)] +
-    #                        sample_data[0..(tick_sample_length * 2)] +
-    #                        sample_data[0...(tick_sample_length * 2)] +
-    #                        sample_data[0..(tick_sample_length * 2)],
-    #                        sample_data[(tick_sample_length * 2)..sample_data.length])
-    helper_test_sample_data(test_tracks[4], tick_sample_length, zeroes(tick_sample_length * 4), [])
-
-
-    tick_sample_length = (W.sample_rate * 60.0) / 99 / 4   # 6681.818181818181818
-    test_tracks = generate_test_data()    
-    assert_equal({:primary => [], :overflow => []}, test_tracks[0].sample_data(tick_sample_length))
-    helper_test_sample_data(test_tracks[1], tick_sample_length, sample_data + zeroes(tick_sample_length - W.sample_data.length), [])
-    helper_test_sample_data(test_tracks[2], tick_sample_length, zeroes(tick_sample_length * 3) + sample_data + zeroes(tick_sample_length - sample_data.length + 1), [])
-    helper_test_sample_data(test_tracks[3], tick_sample_length,
-                            sample_data + zeroes((tick_sample_length * 2) - sample_data.length) +
-                            sample_data + zeroes((tick_sample_length * 2) - sample_data.length + 1) +
-                            sample_data + zeroes((tick_sample_length * 2) - sample_data.length) +
-                            sample_data + zeroes((tick_sample_length * 2) - sample_data.length + 1),
-                            [])
-    helper_test_sample_data(test_tracks[4], tick_sample_length, zeroes(tick_sample_length * 4), [])
-  end
-  
-  def helper_test_sample_data(track, tick_sample_length, expected_primary, expected_overflow)
-    sample_data = track.sample_data(tick_sample_length)
     
-    assert_equal(Hash,                      sample_data.class)
-    assert_equal(["overflow", "primary"],   sample_data.keys.map{|key| key.to_s}.sort)
-    assert_equal(expected_primary.length,   sample_data[:primary].length)
-    assert_equal(expected_overflow.length,  sample_data[:overflow].length)
-    assert_equal(expected_primary,          sample_data[:primary])
-    assert_equal(expected_overflow,         sample_data[:overflow])
+    assert_equal(0,  test_tracks[:blank].step_count())
+    assert_equal(1,  test_tracks[:solo].step_count())
+    assert_equal(4,  test_tracks[:with_overflow].step_count())
+    assert_equal(8,  test_tracks[:with_barlines].step_count())
+    assert_equal(4,  test_tracks[:placeholder].step_count())
+    assert_equal(32, test_tracks[:complicated].step_count())
   end
-  
-private
-
-  def zeroes(length)
-    return [].fill(0, 0, length)
-  end
-end
+end