beats 1.0.0

data/lib/track.rb

@@ -0,0 +1,118 @@
+class Track
+  REST = "."
+  BEAT = "X"
+  
+  def initialize(name, wave_data, pattern)
+    @wave_data = wave_data
+    @name = name
+    @sample_data = nil
+    @overflow = nil
+    self.pattern = pattern
+  end
+  
+  def pattern=(pattern)
+    @pattern = pattern
+    beats = []
+    
+    beat_length = 0
+    #pattern.each_char{|ch|
+    pattern.each_byte{|ch|
+      ch = ch.chr
+      if ch == BEAT
+        beats << beat_length
+        beat_length = 1
+      else
+        beat_length += 1
+      end
+    }
+    
+    if(beat_length > 0)
+      beats << beat_length
+    end
+    if(beats == [])
+      beats = [0]
+    end
+    @beats = beats
+    
+    # Remove any cached sample data
+    @sample_data = nil
+    @overflow = nil
+  end
+  
+  def sample_length(tick_sample_length)
+    total_ticks = @beats.inject(0) {|sum, n| sum + n}
+    return (total_ticks * tick_sample_length).floor
+  end
+  
+  def sample_length_with_overflow(tick_sample_length)
+    temp_sample_length = sample_length(tick_sample_length)
+    
+    if(@beats != [0])
+      beat_sample_length = @beats.last * tick_sample_length
+      if(@wave_data.length > beat_sample_length)
+        temp_sample_length += @wave_data.length - beat_sample_length.floor
+      end
+    end
+    
+    return temp_sample_length.floor
+  end
+  
+  def sample_data(tick_sample_length, incoming_overflow = nil)
+    actual_sample_length = sample_length(tick_sample_length)
+    full_sample_length = sample_length_with_overflow(tick_sample_length)
+
+    if(@sample_data == nil)
+      fill_value = (@wave_data.first.class == Array) ? [0, 0] : 0
+      output_data = [].fill(fill_value, 0, full_sample_length)
+    
+      if(full_sample_length > 0)
+        remainder = 0.0
+        offset = @beats[0] * tick_sample_length
+        remainder += (@beats[0] * tick_sample_length) - (@beats[0] * tick_sample_length).floor
+
+        @beats[1...(@beats.length)].each {|beat_length|
+          beat_sample_length = beat_length * tick_sample_length
+
+          remainder += beat_sample_length - beat_sample_length.floor
+          if(remainder >= 1.0)
+            beat_sample_length += 1
+            remainder -= 1.0
+          end
+
+          output_data[offset...(offset + wave_data.length)] = wave_data
+          offset += beat_sample_length.floor
+        }
+      
+        if(full_sample_length > actual_sample_length)
+          @sample_data = output_data[0...offset]
+          @overflow = output_data[actual_sample_length...full_sample_length]
+        else
+          @sample_data = output_data
+          @overflow = []
+        end
+      else
+        @sample_data = []
+        @overflow = []
+      end
+    end
+
+    primary_sample_data = @sample_data.dup
+    
+    if(incoming_overflow != nil && incoming_overflow != [])
+      # TO DO: Add check for when incoming overflow is longer than
+      # track full length to prevent track from lengthening.
+      intro_length = @beats.first * tick_sample_length.floor
+      
+      if(incoming_overflow.length <= intro_length)
+        primary_sample_data[0...incoming_overflow.length] = incoming_overflow
+      else
+        primary_sample_data[0...intro_length] = incoming_overflow[0...intro_length]
+      end
+    end
+    
+    return {:primary => primary_sample_data, :overflow => @overflow}
+  end
+  
+  attr_accessor :name, :wave_data
+  attr_reader :pattern
+end

data/test/includes.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+require 'yaml'
+require 'song'
+require 'pattern'
+require 'track'
+require 'kit'
+require 'rubygems'
+require 'wavefile'

data/test/kit_test.rb

@@ -0,0 +1,121 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/includes'
+
+class SongTest < Test::Unit::TestCase
+  MIN_SAMPLE_8BIT = 0
+  MAX_SAMPLE_8BIT = 255
+  
+  def test_add
+    # Test adding sounds with progressively higher bits per sample and num channels.
+    # Verify that kit.bits_per_sample and kit.num_channels is ratcheted up.
+    kit = Kit.new()
+    assert_equal(kit.bits_per_sample, 0)
+    assert_equal(kit.num_channels, 0)
+    assert_equal(kit.size, 0)
+    kit.add("mono8", "test/sounds/bass_mono_8.wav")
+    assert_equal(kit.bits_per_sample, 8)
+    assert_equal(kit.num_channels, 1)
+    assert_equal(kit.size, 1)
+    kit.add("mono16", "test/sounds/bass_mono_16.wav")
+    assert_equal(kit.bits_per_sample, 16)
+    assert_equal(kit.num_channels, 1)
+    assert_equal(kit.size, 2)
+    kit.add("stereo16", "test/sounds/bass_stereo_16.wav")
+    assert_equal(kit.bits_per_sample, 16)
+    assert_equal(kit.num_channels, 2)
+    assert_equal(kit.size, 3)
+    
+    # Test adding sounds with progressively lower bits per sample and num channels.
+    # Verify that kit.bits_per_sample and kit.num_channels doesn't change.
+    kit = Kit.new()
+    assert_equal(kit.bits_per_sample, 0)
+    assert_equal(kit.num_channels, 0)
+    kit.add("stereo16", "test/sounds/bass_stereo_16.wav")
+    assert_equal(kit.bits_per_sample, 16)
+    assert_equal(kit.num_channels, 2)
+    kit.add("mono16", "test/sounds/bass_mono_16.wav")
+    assert_equal(kit.bits_per_sample, 16)
+    assert_equal(kit.num_channels, 2)
+    kit.add("mono8", "test/sounds/bass_mono_8.wav")
+    assert_equal(kit.bits_per_sample, 16)
+    assert_equal(kit.num_channels, 2)
+  end
+  
+  def test_get_sample_data
+    kit = Kit.new()
+    
+    assert_raise(StandardError) { kit.get_sample_data("nonexistant") }
+    
+    # Test adding sounds with progressively higher bits per sample and num channels.
+    # Verify that sample data bits per sample and num channels is ratcheted up.
+    kit.add("mono8", "test/sounds/bass_mono_8.wav")
+    sample_data = kit.get_sample_data("mono8")
+    assert(sample_data.max <= MAX_SAMPLE_8BIT)
+    assert(sample_data.min >= MIN_SAMPLE_8BIT)
+    all_are_fixnums = true
+    sample_data.each {|sample|
+      all_are_fixnums &&= sample.class == Fixnum
+    }
+    assert(all_are_fixnums)
+    
+    kit.add("mono16", "test/sounds/bass_mono_16.wav")
+    sample_data = kit.get_sample_data("mono8")
+    assert(sample_data.max > MAX_SAMPLE_8BIT)
+    assert(sample_data.min < MIN_SAMPLE_8BIT)
+    all_are_fixnums = true
+    sample_data.each {|sample|
+      all_are_fixnums &&= sample.class == Fixnum
+    }
+    assert(all_are_fixnums)
+    
+    kit.add("stereo16", "test/sounds/bass_stereo_16.wav")
+    sample_data = kit.get_sample_data("stereo16")
+    assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
+    assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)
+    all_are_arrays = true
+    sample_data.each {|sample|
+      all_are_arrays &&= sample.class == Array
+    }
+    assert(all_are_arrays)
+    assert(sample_data.first.length == 2)
+    
+    
+    # Test adding sounds with progressively lower bits per sample and num channels.
+    # Verify that sample data bits per sample and num channels doesn't go down.
+    kit = Kit.new()
+    
+    kit.add("stereo16", "test/sounds/bass_stereo_16.wav")
+    sample_data = kit.get_sample_data("stereo16")
+    assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
+    assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)
+    all_are_arrays = true
+    sample_data.each {|sample|
+      all_are_arrays &&= sample.class == Array
+    }
+    assert(all_are_arrays)
+    assert(sample_data.first.length == 2)
+    
+    kit.add("mono16", "test/sounds/bass_mono_16.wav")
+    sample_data = kit.get_sample_data("mono16")
+    assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
+    assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)
+    all_are_arrays = true
+    sample_data.each {|sample|
+      all_are_arrays &&= sample.class == Array
+    }
+    assert(all_are_arrays)
+    assert(sample_data.first.length == 2)
+    
+    kit.add("mono8", "test/sounds/bass_mono_8.wav")
+    sample_data = kit.get_sample_data("mono8")
+    assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
+    assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)
+    all_are_arrays = true
+    sample_data.each {|sample|
+      all_are_arrays &&= sample.class == Array
+    }
+    assert(all_are_arrays)
+    assert(sample_data.first.length == 2)
+  end
+end

data/test/pattern_test.rb

@@ -0,0 +1,153 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/includes'
+
+class PatternTest < Test::Unit::TestCase
+  SAMPLE_RATE = 44100
+  SECONDS_IN_MINUTE = 60.0
+
+  def generate_test_data
+    kit = Kit.new()
+    kit.add("bass.wav",      "test/sounds/bass_mono_8.wav")
+    kit.add("snare.wav",     "test/sounds/snare_mono_8.wav")
+    kit.add("hh_closed.wav", "test/sounds/hh_closed_mono_8.wav")
+    kit.add("hh_open.wav",   "test/sounds/hh_open_mono_8.wav")
+    
+    test_patterns = []
+    
+    p1 = Pattern.new :blank
+    test_patterns << p1
+    
+    p2 = Pattern.new :verse
+    p2.track "bass.wav",      kit.get_sample_data("bass.wav"),      "X...X...X...XX..X...X...XX..X..."
+    p2.track "snare.wav",     kit.get_sample_data("snare.wav"),     "..X...X...X...X.X...X...X...X..."
+    p2.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."
+    p2.track "hh_open.wav",   kit.get_sample_data("hh_open.wav"),   "X...............X..............X"
+    test_patterns << p2
+    
+    p3 = Pattern.new :staircase
+    p3.track "bass.wav",      kit.get_sample_data("bass.wav"),      "X..."
+    p3.track "snare.wav",     kit.get_sample_data("snare.wav"),     "X.."
+    p3.track "hh_closed.wav", kit.get_sample_data("hh_closed.wav"), "X."
+    test_patterns << p3
+    
+    return test_patterns
+  end
+  
+  def test_initialize
+    test_patterns = generate_test_data()
+    
+    pattern = test_patterns.shift()
+    assert_equal(pattern.name, :blank)
+    assert_equal(pattern.tracks.length, 0)
+
+    pattern = test_patterns.shift()
+    assert_equal(pattern.name, :verse)
+    assert_equal(pattern.tracks.length, 4)
+
+    pattern = test_patterns.shift()
+    assert_equal(pattern.name, :staircase)
+    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[0].sample_length(tick_sample_length), 0)
+    assert_equal(test_patterns[1].sample_length(tick_sample_length), tick_sample_length * 32)
+    assert_equal(test_patterns[2].sample_length(tick_sample_length), tick_sample_length * 4)
+
+    tick_sample_length = 6681.81818181818
+    assert_equal(test_patterns[0].sample_length(tick_sample_length), 0)
+    assert_equal(test_patterns[1].sample_length(tick_sample_length), (tick_sample_length * 32).floor)
+    assert_equal(test_patterns[2].sample_length(tick_sample_length), (tick_sample_length * 4).floor)
+
+    tick_sample_length = 16134.1463414634
+    assert_equal(test_patterns[0].sample_length(tick_sample_length), 0)
+    assert_equal(test_patterns[1].sample_length(tick_sample_length), (tick_sample_length * 32).floor)
+    assert_equal(test_patterns[2].sample_length(tick_sample_length), (tick_sample_length * 4).floor)
+  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{|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 {|track_overflow|
+        assert_equal(track_overflow.class, Array)
+      }
+      # To do: add test to verify that longest overflow == full_sample_length - primary_sample_length
+    }
+
+    #Split
+    track_samples = test_patterns[0].sample_data(tick_sample_length, 1, 0, {}, true)
+    assert_equal(track_samples.class, Hash)
+    assert_equal(track_samples.keys.map{|key| key.to_s}.sort, ["overflow", "primary"])
+
+    track_samples = test_patterns[1].sample_data(tick_sample_length, 1, 4, {}, true)
+    assert_equal(track_samples.class, Hash)
+    assert_equal(track_samples[:primary].keys.map{|key| key.to_s}.sort,
+                 ["bass.wav", "hh_closed.wav", "hh_open.wav", "snare.wav"])
+    primary = track_samples[:primary]
+    primary.keys.each{|name|
+      assert_equal(primary[name].length, test_patterns[1].sample_length(tick_sample_length))
+    }
+    overflow = track_samples[:overflow]
+    longest_overflow = find_longest_overflow(overflow)
+    overflow.keys.each{|name|
+      assert_equal(overflow[name].class, Array)
+      #assert_lessthan(overflow[name].length, test_patterns[1].sample_length_with_overflow(tick_sample_length) - test_patterns[1].sample_length(tick_sample_length))
+    }
+    assert_equal(overflow[longest_overflow].length, test_patterns[1].sample_length_with_overflow(tick_sample_length) - test_patterns[1].sample_length(tick_sample_length))
+
+    track_samples = test_patterns[2].sample_data(tick_sample_length, 1, 3, {}, true)
+    assert_equal(track_samples.class, Hash)
+    assert_equal(track_samples[:primary].keys.map{|key| key.to_s}.sort,
+                 ["bass.wav", "hh_closed.wav", "snare.wav"])
+    primary = track_samples[:primary]
+    primary.keys.each{|name|
+      assert_equal(primary[name].length, test_patterns[2].sample_length(tick_sample_length))
+    }
+    overflow = track_samples[:overflow]
+    longest_overflow = find_longest_overflow(overflow)
+    overflow.keys.each{|name|
+      assert_equal(overflow[name].class, Array)
+    }
+    assert_equal(overflow[longest_overflow].length, test_patterns[2].sample_length_with_overflow(tick_sample_length) - test_patterns[2].sample_length(tick_sample_length))
+    primary.keys.each{|name|
+      assert_equal(primary[name].length, (tick_sample_length * 4).floor)
+      assert_equal(primary[name].length, test_patterns[2].sample_length(tick_sample_length))
+    }
+  end
+  
+  def find_longest_overflow(overflow)
+    longest_overflow = overflow.keys.first
+    overflow.keys.each {|name|
+      if(overflow[name].length > overflow[longest_overflow].length)
+        longest_overflow = name
+      end
+    }
+    
+    return longest_overflow
+  end
+end

data/test/song_test.rb

@@ -0,0 +1,225 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/includes'
+
+class MockSong < Song
+  attr_reader :patterns
+  attr_accessor :kit
+end
+
+class SongTest < Test::Unit::TestCase
+  DEFAULT_TEMPO = 120
+  
+  def generate_test_data
+    kit = Kit.new()
+    kit.add("bass.wav",      "test/sounds/bass_mono_8.wav")
+    kit.add("snare.wav",     "test/sounds/snare_mono_8.wav")
+    kit.add("hh_closed.wav", "test/sounds/hh_closed_mono_8.wav")
+    kit.add("ride.wav",      "test/sounds/ride_mono_8.wav")
+    
+    test_songs = {}
+    
+    test_songs[:blank] = MockSong.new(File.dirname(__FILE__) + "/..")
+    
+    test_songs[:no_structure] = MockSong.new(File.dirname(__FILE__) + "/..")
+    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."
+    
+    repeats_not_specified_yaml = "
+Song:
+  Tempo: 100
+  Structure:
+    - Verse
+    
+Verse:
+  - test/sounds/bass_mono_8.wav: X"
+    test_songs[:repeats_not_specified] = MockSong.new(File.dirname(__FILE__) + "/..", repeats_not_specified_yaml)
+    
+    overflow_yaml = "
+Song:
+  Tempo: 100
+  Structure:
+    - Verse: x2
+
+Verse:
+  - test/sounds/snare_mono_8.wav: ...X"
+    test_songs[:overflow] = MockSong.new(File.dirname(__FILE__) + "/..", overflow_yaml)
+    
+    test_songs[:from_code] = MockSong.new(File.dirname(__FILE__) + "/..")
+    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."
+    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
+    
+    valid_yaml_string = "# An example song
+
+Song:
+  Tempo: 99
+  Structure:
+    - Verse:  x2
+    - Chorus: x2
+    - Verse:  x2
+    - Chorus: x4
+    - Bridge: x1
+    - 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] = MockSong.new(File.dirname(__FILE__) + "/..", valid_yaml_string)
+    
+    return test_songs
+  end
+    
+  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[: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[: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(test_songs[:from_valid_yaml_string].structure, [:verse, :verse, :chorus, :chorus, :verse, :verse, :chorus, :chorus, :chorus, :chorus, :bridge, :chorus, :chorus, :chorus, :chorus])
+    assert_equal(test_songs[:from_valid_yaml_string].tempo, 99)
+    assert_equal(test_songs[:from_valid_yaml_string].tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / 99 / 4.0)
+    assert_equal(test_songs[:from_valid_yaml_string].patterns.keys.map{|key| key.to_s}.sort, ["bridge", "chorus", "verse"])
+    assert_equal(test_songs[:from_valid_yaml_string].patterns[:verse].tracks.length, 4)
+    assert_equal(test_songs[:from_valid_yaml_string].patterns[:chorus].tracks.length, 5)
+    assert_equal(test_songs[:from_valid_yaml_string].patterns[:bridge].tracks.length, 1)
+  end
+  
+  def test_invalid_initialize
+    invalid_tempo_yaml_string = "# Invalid tempo song
+    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 = MockSong.new(File.dirname(__FILE__) + "/..", invalid_tempo_yaml_string) }
+    
+    invalid_structure_yaml_string = "# Invalid structure song
+    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 = MockSong.new(File.dirname(__FILE__) + "/..", invalid_structure_yaml_string) }
+    
+    invalid_repeats_yaml_string = "    # Invalid structure song
+    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 = MockSong.new(File.dirname(__FILE__) + "/..", invalid_repeats_yaml_string) }
+  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)
+  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(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[:repeats_not_specified].sample_length,
+                            test_songs[:repeats_not_specified].tick_sample_length)
+                            
+    assert_equal(test_songs[:overflow].sample_length, test_songs[:overflow].tick_sample_length * 8)
+  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)
+    
+    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[:repeats_not_specified].sample_length_with_overflow,
+                 test_songs[:repeats_not_specified].tick_sample_length)
+    
+    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)
+    
+    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)
+  end
+  
+  def test_sample_data
+    test_songs = generate_test_data()
+    
+    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])
+  end
+end