beats 1.1.0 → 1.2.0

data/test/song_test.rb

@@ -12,27 +12,23 @@ class SongTest < Test::Unit::TestCase
     kit.add("hh_closed.wav", "hh_closed_mono_8.wav")
     kit.add("ride.wav",      "ride_mono_8.wav")
     
-    test_songs = SongParserTest.generate_test_data()
-    
-    test_songs[:blank] = Song.new("test/sounds")
+    test_songs = {}
+    base_path = File.dirname(__FILE__) + "/.."
+
+    test_songs[:blank] = Song.new(base_path)
     
-    test_songs[:no_structure] = Song.new("test/sounds")
+    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."
     
-    overflow_yaml = "
-Song:
-  Tempo: 100
-  Structure:
-    - Verse: x2
-
-Verse:
-  - test/sounds/snare_mono_8.wav: ...X"
-    test_songs[:overflow] = SongParser.new().parse(File.dirname(__FILE__) + "/..", overflow_yaml)
+    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("test/sounds")
+    test_songs[:from_code] = Song.new(base_path)
     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..."
@@ -50,90 +46,119 @@ Verse:
   def test_initialize
     test_songs = generate_test_data()
     
-    assert_equal(test_songs[:blank].structure, [])
-    assert_equal(test_songs[:blank].tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0)
+    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(test_songs[:no_structure].tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0)
+    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(test_songs[:from_code].structure, [:verse, :chorus, :verse, :chorus, :chorus])
-    assert_equal(test_songs[:from_code].tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0)
+    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)
   end
   
   def test_total_tracks
     test_songs = generate_test_data()
     
-    assert_equal(test_songs[:blank].total_tracks, 0)
-    assert_equal(test_songs[:no_structure].total_tracks, 3)
-    assert_equal(test_songs[:from_code].total_tracks, 3)
-    assert_equal(test_songs[:repeats_not_specified].total_tracks, 1)
-    assert_equal(test_songs[:overflow].total_tracks, 1)
-    assert_equal(test_songs[:from_valid_yaml_string].total_tracks, 5)
+    assert_equal(0, test_songs[:blank].total_tracks)
+    assert_equal(3, test_songs[:no_structure].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)
+  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", "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/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)
   end
   
   def test_sample_length
     test_songs = generate_test_data()
 
-    assert_equal(test_songs[:blank].sample_length, 0)
-    assert_equal(test_songs[:no_structure].sample_length, 0)
+    assert_equal(0, test_songs[:blank].sample_length)
+    assert_equal(0, test_songs[:no_structure].sample_length)
     
-    assert_equal(test_songs[:from_code].sample_length,
-                            (test_songs[:from_code].tick_sample_length * 16 * 2) +
-                            (test_songs[:from_code].tick_sample_length * 8 * 3))
+    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].sample_length,
-                            test_songs[:repeats_not_specified].tick_sample_length)
+    assert_equal(test_songs[:repeats_not_specified].tick_sample_length,
+                 test_songs[:repeats_not_specified].sample_length)
                             
-    assert_equal(test_songs[:overflow].sample_length, test_songs[:overflow].tick_sample_length * 8)
+    assert_equal(test_songs[:overflow].tick_sample_length * 8, test_songs[:overflow].sample_length)
   end
   
   def test_sample_length_with_overflow
     test_songs = generate_test_data()
     
-    assert_equal(test_songs[:blank].sample_length_with_overflow, 0)
-    assert_equal(test_songs[:no_structure].sample_length_with_overflow, 0)
+    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_with_overflow, test_songs[:from_code].sample_length + snare_overflow)    
+    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].sample_length_with_overflow,
-                 test_songs[:repeats_not_specified].tick_sample_length)
+    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].sample_length_with_overflow,
-                 (test_songs[:overflow].tick_sample_length * 8) + snare_overflow)
+    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_with_overflow, test_songs[:from_valid_yaml_string].sample_length + snare_overflow)
+    assert_equal(test_songs[:from_valid_yaml_string].sample_length + snare_overflow,
+                 test_songs[:from_valid_yaml_string].sample_length_with_overflow)
+  end
+  
+  def test_copy_ignoring_patterns_and_structure
+    test_songs = generate_test_data()
+    original_song = test_songs[:from_valid_yaml_string]
+    cloned_song = original_song.copy_ignoring_patterns_and_structure()
+    
+    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)
+  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(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)
   end
   
-  def test_sample_data
+  def test_to_yaml
     test_songs = generate_test_data()
+    result = test_songs[:from_valid_yaml_string_with_kit].to_yaml
     
-    test_songs.values.each {|song|
-      sample_data = song.sample_data("", false)
-      assert_equal(sample_data.class, Array)
-      assert_equal(sample_data.length, song.sample_length_with_overflow)
-      sample_data = song.sample_data("", true)
-      assert_equal(sample_data.class, Hash)
-    }
-    
-    [:from_code, :repeats_not_specified, :overflow, :from_valid_yaml_string].each {|key|
-      assert_equal(test_songs[key].sample_data("verse", false).class, Array)
-      assert_equal(test_songs[key].sample_data("verse", true).class, Hash)
-    }
-    
-    snare_sample_data = test_songs[:overflow].kit.get_sample_data("test/sounds/snare_mono_8.wav")
-    expected = [].fill(0, 0, test_songs[:overflow].tick_sample_length * 4)
-    expected[0...(snare_sample_data.length)] = snare_sample_data
-    expected += snare_sample_data
-    expected = [].fill(0, 0, test_songs[:overflow].tick_sample_length * 3) + expected
-    assert_equal(test_songs[:overflow].sample_data("", false)[0], expected[0])
+    assert_equal(File.read("test/fixtures/yaml/song_yaml.txt"), result)
   end
 end

data/test/songoptimizer_test.rb

@@ -0,0 +1,162 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/includes'
+
+class MockSongOptimizer < SongOptimizer
+  def clone_song_ignoring_patterns_and_structure(original_song)
+    return super
+  end
+end
+
+class SongOptimizerTest < Test::Unit::TestCase
+  EXAMPLE_SONG_YAML = "
+Song:
+  Tempo: 135
+  Structure:
+    - Verse:   x2
+    - Chorus:  x4
+    - Verse:   x2
+    - Chorus:  x4
+  Kit:
+    - bass:       sounds/bass.wav
+    - snare:      sounds/snare.wav
+    - hh_closed:  sounds/hh_closed.wav
+    - agogo:      sounds/agogo_high.wav
+
+Verse:
+  - bass:             X...X...X...X...
+  - snare:            ..............X.
+  - hh_closed:        X.XXX.XXX.X.X.X.
+  - agogo:            ..............XX
+
+Chorus:
+  - bass:             X...X...XX..X...
+  - snare:            ....X.......X...
+  - hh_closed:        X.XXX.XXX.XX..X.
+  - sounds/tom4.wav:  ...........X....
+  - sounds/tom2.wav:  ..............X."
+  
+  EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN = "
+Song:
+  Tempo: 135
+  Structure:
+    - Verse:   x1
+  Kit:
+    - bass:   sounds/bass.wav
+    - snare:  sounds/snare.wav
+
+Verse:
+  - bass:   X.......X...
+  - snare:  ..........X."
+
+  def test_optimize
+    parser = SongParser.new()
+    original_song = 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)
+    #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],
+                 optimized_song.patterns.keys.sort {|x, y| x.to_s <=> y.to_s })
+        
+    pattern = optimized_song.patterns[:verse8]
+    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]
+    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]
+    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]
+    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]
+    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]
+    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])
+  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)
+    
+    optimizer = SongOptimizer.new()
+    optimized_song = optimizer.optimize(original_song, 7)
+    
+    pattern = optimized_song.patterns[:verse0]
+    assert_equal(["bass"], pattern.tracks.keys.sort)
+    assert_equal("X......", pattern.tracks["bass"].rhythm)
+    
+    pattern = optimized_song.patterns[:verse7]
+    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)
+  end
+  
+  def test_optimize_song_containing_empty_pattern()
+    parser = SongParser.new()
+    original_song = 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]
+    assert_equal(["bass"], pattern.tracks.keys.sort)
+    assert_equal("X...", pattern.tracks["bass"].rhythm)
+    
+    pattern = optimized_song.patterns[:verse4]
+    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]
+    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)
+  end
+end

data/test/songparser_test.rb

@@ -2,7 +2,7 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
 require 'test/includes'
 
-class SongParserTest < Test::Unit::TestCase
+class SongParserTest < Test::Unit::TestCase  
   def self.generate_test_data
     kit = Kit.new("test/sounds")
     kit.add("bass.wav",      "bass_mono_8.wav")
@@ -13,107 +13,18 @@ class SongParserTest < Test::Unit::TestCase
     test_songs = {}
     base_path = File.dirname(__FILE__) + "/.."
 
-    no_tempo_yaml = "
-Song:
-  Structure:
-    - Verse: x1
-
-Verse:
-  - test/sounds/bass_mono_8.wav: X"
-    test_songs[:no_tempo] = SongParser.new().parse(base_path, no_tempo_yaml)
-
-    repeats_not_specified_yaml = "
-Song:
-  Tempo: 100
-  Structure:
-    - Verse
-
-Verse:
-  - test/sounds/bass_mono_8.wav: X"
-    test_songs[:repeats_not_specified] = SongParser.new().parse(base_path, repeats_not_specified_yaml)
-
-    overflow_yaml = "
-Song:
-  Tempo: 100
-  Structure:
-    - Verse: x2
-
-Verse:
-  - test/sounds/snare_mono_8.wav: ...X"
-    test_songs[:overflow] = SongParser.new().parse(base_path, overflow_yaml)
-
-    valid_yaml_string = "# An example song
-  
-Song:
-  Tempo: 99
-  Structure:
-    - Verse:     x2
-    - Chorus:    x2
-    - Verse:     x2
-    - Chorus:    x4
-    - Bridge:    x1
-    - Undefined: x0  # This is legal as long as num repeats is 0.
-    - Chorus:    x4
-
-Verse:
-  - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X...
-  - test/sounds/snare_mono_8.wav:     ..X...X...X...X.X...X...X...X...
-# Here is a comment
-  - test/sounds/hh_closed_mono_8.wav: X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.
-  - test/sounds/hh_open_mono_8.wav:   X...............X..............X
-# Here is another comment
-Chorus:
-  - test/sounds/bass_mono_8.wav:      X...X...XXXXXXXXX...X...X...X...
-  - test/sounds/snare_mono_8.wav:     ...................X...X...X...X
-  - test/sounds/hh_closed_mono_8.wav: X.X.XXX.X.X.XXX.X.X.XXX.X.X.XXX. # It's comment time
-  - test/sounds/hh_open_mono_8.wav:   ........X.......X.......X.......
-  - test/sounds/ride_mono_8.wav:      ....X...................X.......
-
-
-Bridge:
-  - test/sounds/hh_closed_mono_8.wav: XX.XXX.XXX.XXX.XXX.XXX.XXX.XXX.X"
-    test_songs[:from_valid_yaml_string] = SongParser.new().parse(base_path, valid_yaml_string)
-
-    valid_yaml_string_with_kit = "# An example song
-
-Song:
-  Tempo: 99
-  Kit:
-    - bass:     test/sounds/bass_mono_8.wav
-    - snare:    test/sounds/snare_mono_8.wav
-    - hhclosed: test/sounds/hh_closed_mono_8.wav
-    - hhopen:   test/sounds/hh_open_mono_8.wav
-  Structure:
-    - Verse:  x2
-    - Chorus: x2
-    - Verse:  x2
-    - Chorus: x4
-    - Bridge: x1
-    - Undefined: x0  # This is legal as long as num repeats is 0.
-    - Chorus: x4
-
-Verse:
-  - base:      X...X...X...XX..X...X...XX..X...
-  - snare:     ..X...X...X...X.X...X...X...X...
-# Here is a comment
-  - hhclosed:  X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.
-  - hhopen:    X...............X..............X
-# Here is another comment
-Chorus:
-  - bass:      X...X...XXXXXXXXX...X...X...X...
-  - snare:     ...................X...X...X...X
-  - test/sounds/hh_closed_mono_8.wav: X.X.XXX.X.X.XXX.X.X.XXX.X.X.XXX. # It's comment time
-  - hhopen:    ........X.......X.......X.......
-  - test/sounds/ride_mono_8.wav:      ....X...................X.......
-
-Bridge:
-  - hhclosed: XX.XXX.XXX.XXX.XXX.XXX.XXX.XXX.X"
-    test_songs[:from_valid_yaml_string_with_kit] = SongParser.new().parse(base_path, valid_yaml_string)
+    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"))
 
     return test_songs
   end
 
-  def test_valid_initialize
+  def test_valid_parse
     test_songs = SongParserTest.generate_test_data()
     
     assert_equal(test_songs[:no_tempo].tempo, 120)
@@ -124,7 +35,7 @@ Bridge:
     
     # 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 {|song_key|
+    [:from_valid_yaml_string, :from_valid_yaml_string_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)
@@ -133,75 +44,35 @@ Bridge:
       assert_equal(song.patterns[:verse].tracks.length, 4)
       assert_equal(song.patterns[:chorus].tracks.length, 5)
       assert_equal(song.patterns[:bridge].tracks.length, 1)
-    }
+    end
+    
+    song = test_songs[:from_valid_yaml_string_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)
   end
   
-  def test_invalid_initialize
-    no_header_yaml_string = "# Song with no header
-    Verse:
-      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
-    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", no_header_yaml_string) }
-    
-    sound_doesnt_exist_yaml_string = "# Song with non-existent sound
-    Song:
-      Tempo: 100
-      Structure:
-        - Verse: x1
-        
-    Verse:
-      - test/sounds/i_do_not_exist.wav: X...X..."
-    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", sound_doesnt_exist_yaml_string) }
-    
-    
-    sound_doesnt_exist_in_kit_yaml_string = "# Song with non-existent sound in Kit
-    Song:
-      Tempo: 100
-      Structure:
-        - Verse: x1
-      Kit:
-        - bad: test/sounds/i_do_not_exist.wav
-      
-    Verse:
-      - bad: X...X..."
-    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", sound_doesnt_exist_in_kit_yaml_string) }
+  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_tempo_yaml_string = "# Song with invalid tempo
-    Song:
-      Tempo: 100a
-      Structure:
-        - Verse:  x2
-
-    Verse:
-      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
-    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", invalid_tempo_yaml_string) }
-
-    invalid_structure_yaml_string = "# Song whose structure references non-existent pattern
-    Song:
-      Tempo: 100
-      Structure:
-        - Verse:  x2
-        - Chorus: x1
-
-    Verse:
-      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
-    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", invalid_structure_yaml_string) }
+    invalid_fixtures.each do |fixture|
+      assert_raise(SongParseError) do
+        song = SongParser.new().parse(File.dirname(__FILE__) + "/..",
+                                      YAML.load_file("test/fixtures/invalid/" + fixture + ".txt"))
+      end
+    end
     
-    no_structure_yaml_string = "# Song without a structure section in the header
-    Song:
-      Tempo: 100
-
-    Verse:
-      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
-    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", no_structure_yaml_string) }
-    
-    invalid_repeats_yaml_string = "# Song with invalid number of repeats for pattern
-    Song:
-      Tempo: 100
-      Structure:
-        - Verse:  x2a
-
-    Verse:
-      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
-    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", invalid_repeats_yaml_string) }
+    assert_raise(InvalidRhythmError) do
+      song = SongParser.new().parse(File.dirname(__FILE__) + "/..",
+                                    YAML.load_file("test/fixtures/invalid/bad_rhythm.txt"))
+    end
   end
 end