beats 1.1.0 → 1.2.0

data/test/includes.rb

@@ -1,9 +1,16 @@
+# Standard Ruby libraries
 require 'test/unit'
 require 'yaml'
+require 'rubygems'
+require 'wavefile'
+
+# BEATS classes
+require 'beats'
+require 'kit'
+require 'pattern'
 require 'song'
 require 'songparser'
-require 'pattern'
+require 'songoptimizer'
+require 'songsplitter'
 require 'track'
-require 'kit'
-require 'rubygems'
-require 'wavefile'
+require 'beatswavefile'

data/test/integration.rb

@@ -0,0 +1,100 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/includes'
+
+class SongParserTest < Test::Unit::TestCase
+  TRACK_NAMES =  ["bass", "snare", "hh_closed", "agogo", "tom4", "tom2"]
+  OUTPUT_FOLDER = "test/integration_output"
+  
+  def test_bad_song_errors
+    invalid_fixtures = ["bad_tempo.txt",
+                        "bad_repeat_count.txt",
+                        "bad_structure.txt",
+                        "no_header.txt",
+                        "no_structure.txt",
+                        "sound_in_kit_not_found.txt",
+                        "sound_in_track_not_found.txt"]
+        
+    invalid_fixtures.each do |fixture_name|
+      assert_raise(SongParseError) do
+        beats = Beats.new("test/fixtures/invalid/#{fixture_name}", "doesn't matter", {:split => false, :pattern => nil})
+        beats.run()
+      end
+    end
+  end
+  
+  
+  # TODO: Add tests for the -p option
+  # TODO: Add test verify that song generated with and without SongOptimizer are identical.
+  
+  def test_generate_combined
+    # Make sure no output from previous tests is still around
+    clean_output_folder()
+    
+    run_combined_test("mono",   8)
+    run_combined_test("mono",   16)
+    run_combined_test("stereo", 8)
+    run_combined_test("stereo", 16)
+  end
+  
+  def run_combined_test(num_channels, bits_per_sample)
+    # Make sure no output from previous tests is still around
+    assert_equal([".", ".."], Dir.new(OUTPUT_FOLDER).entries)
+    
+    song_fixture         = "test/fixtures/valid/example_#{num_channels}_#{bits_per_sample}.txt"
+    actual_output_file   = "#{OUTPUT_FOLDER}/example_combined_#{num_channels}_#{bits_per_sample}.wav"
+    expected_output_file = "test/fixtures/expected_output/example_combined_#{num_channels}_#{bits_per_sample}.wav"
+    
+    beats = Beats.new(song_fixture, actual_output_file, {:split => false, :pattern => nil})
+    beats.run()
+    assert(File.exists?(actual_output_file), "Expected file '#{actual_output_file}' to exist, but it doesn't.")
+    assert_equal(File.read(expected_output_file), File.read(actual_output_file))
+    
+    # Clean up after ourselves
+    File.delete(actual_output_file)
+  end
+  
+  def test_generate_split
+    # Make sure no output from previous tests is still around
+    clean_output_folder()
+    
+    run_split_test("mono",    8)
+    run_split_test("mono",   16)
+    run_split_test("stereo",  8)
+    run_split_test("stereo", 16)
+  end
+  
+  def run_split_test(num_channels, bits_per_sample)
+    # Make sure no output from previous tests is still around
+    assert_equal([".", ".."], Dir.new(OUTPUT_FOLDER).entries)
+    
+    song_fixture         = "test/fixtures/valid/example_#{num_channels}_#{bits_per_sample}.txt"
+    actual_output_prefix   = "#{OUTPUT_FOLDER}/example_split_#{num_channels}_#{bits_per_sample}"
+    expected_output_prefix = "test/fixtures/expected_output/example_split_#{num_channels}_#{bits_per_sample}"
+    
+    beats = Beats.new(song_fixture, actual_output_prefix + ".wav", {:split => true, :pattern => nil})
+    beats.run()
+    TRACK_NAMES.each do |track_name|
+      if(track_name.start_with?("tom"))
+        track_name += "_#{num_channels}_#{bits_per_sample}"
+      end
+      actual_output_file = "#{actual_output_prefix}-#{track_name}.wav"
+      expected_output_file = "#{expected_output_prefix}-#{track_name}.wav"
+      assert(File.exists?(actual_output_file), "Expected file '#{actual_output_file}' to exist, but it doesn't.")
+      assert_equal(File.read(expected_output_file), File.read(actual_output_file))
+      
+      # Clean up after ourselves
+      File.delete(actual_output_file)
+    end
+  end
+  
+  def clean_output_folder()
+    dir = Dir.new(OUTPUT_FOLDER)
+    file_names = dir.entries
+    file_names.each do |file_name|
+      if(file_name != "." && file_name != "..")
+        File.delete("#{OUTPUT_FOLDER}/#{file_name}")
+      end
+    end
+  end
+end

data/test/kit_test.rb

@@ -10,36 +10,36 @@ class SongTest < Test::Unit::TestCase
     # 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("test/sounds")
-    assert_equal(kit.bits_per_sample, 0)
-    assert_equal(kit.num_channels, 0)
-    assert_equal(kit.size, 0)
+    assert_equal(16,  kit.bits_per_sample)
+    assert_equal(1,  kit.num_channels)
+    assert_equal(0,  kit.size)
     kit.add("mono8", "bass_mono_8.wav")
-    assert_equal(kit.bits_per_sample, 8)
-    assert_equal(kit.num_channels, 1)
-    assert_equal(kit.size, 1)
+    assert_equal(16,  kit.bits_per_sample)
+    assert_equal(1,  kit.num_channels)
+    assert_equal(1,  kit.size)
     kit.add("mono16", "bass_mono_16.wav")
-    assert_equal(kit.bits_per_sample, 16)
-    assert_equal(kit.num_channels, 1)
-    assert_equal(kit.size, 2)
+    assert_equal(16, kit.bits_per_sample)
+    assert_equal(1,  kit.num_channels)
+    assert_equal(2,  kit.size)
     kit.add("stereo16", "bass_stereo_16.wav")
-    assert_equal(kit.bits_per_sample, 16)
-    assert_equal(kit.num_channels, 2)
-    assert_equal(kit.size, 3)
+    assert_equal(16, kit.bits_per_sample)
+    assert_equal(2,  kit.num_channels)
+    assert_equal(3,  kit.size)
     
     # 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("test/sounds")
-    assert_equal(kit.bits_per_sample, 0)
-    assert_equal(kit.num_channels, 0)
+    assert_equal(16,  kit.bits_per_sample)
+    assert_equal(1,  kit.num_channels)
     kit.add("stereo16", "bass_stereo_16.wav")
-    assert_equal(kit.bits_per_sample, 16)
-    assert_equal(kit.num_channels, 2)
+    assert_equal(16, kit.bits_per_sample)
+    assert_equal(2,  kit.num_channels)
     kit.add("mono16", "bass_mono_16.wav")
-    assert_equal(kit.bits_per_sample, 16)
-    assert_equal(kit.num_channels, 2)
+    assert_equal(16, kit.bits_per_sample)
+    assert_equal(2,  kit.num_channels)
     kit.add("mono8", "bass_mono_8.wav")
-    assert_equal(kit.bits_per_sample, 16)
-    assert_equal(kit.num_channels, 2)
+    assert_equal(16, kit.bits_per_sample)
+    assert_equal(2,  kit.num_channels)
   end
   
   def test_invalid_add
@@ -56,32 +56,32 @@ class SongTest < Test::Unit::TestCase
     # Verify that sample data bits per sample and num channels is ratcheted up.
     kit.add("mono8", "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)
+    assert(sample_data.max > MAX_SAMPLE_8BIT)
+    assert(sample_data.min < 0)
     all_are_fixnums = true
-    sample_data.each {|sample|
+    sample_data.each do |sample|
       all_are_fixnums &&= sample.class == Fixnum
-    }
+    end
     assert(all_are_fixnums)
     
     kit.add("mono16", "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)
+    assert(sample_data.min < 0)
     all_are_fixnums = true
-    sample_data.each {|sample|
+    sample_data.each do |sample|
       all_are_fixnums &&= sample.class == Fixnum
-    }
+    end
     assert(all_are_fixnums)
     
     kit.add("stereo16", "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)
+    assert(sample_data.flatten.min < 0)
     all_are_arrays = true
-    sample_data.each {|sample|
+    sample_data.each do |sample|
       all_are_arrays &&= sample.class == Array
-    }
+    end
     assert(all_are_arrays)
     assert(sample_data.first.length == 2)
     
@@ -93,33 +93,33 @@ class SongTest < Test::Unit::TestCase
     kit.add("stereo16", "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)
+    assert(sample_data.flatten.min < 0)
     all_are_arrays = true
-    sample_data.each {|sample|
+    sample_data.each do |sample|
       all_are_arrays &&= sample.class == Array
-    }
+    end
     assert(all_are_arrays)
     assert(sample_data.first.length == 2)
     
     kit.add("mono16", "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)
+    assert(sample_data.flatten.min < 0)
     all_are_arrays = true
-    sample_data.each {|sample|
+    sample_data.each do |sample|
       all_are_arrays &&= sample.class == Array
-    }
+    end
     assert(all_are_arrays)
     assert(sample_data.first.length == 2)
     
     kit.add("mono8", "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)
+    assert(sample_data.flatten.min < 0)
     all_are_arrays = true
-    sample_data.each {|sample|
+    sample_data.each do |sample|
       all_are_arrays &&= sample.class == Array
-    }
+    end
     assert(all_are_arrays)
     assert(sample_data.first.length == 2)
   end

data/test/pattern_test.rb

@@ -13,23 +13,23 @@ class PatternTest < Test::Unit::TestCase
     kit.add("hh_closed.wav", "hh_closed_mono_8.wav")
     kit.add("hh_open.wav",   "hh_open_mono_8.wav")
     
-    test_patterns = []
+    test_patterns = {}
     
-    p1 = Pattern.new :blank
-    test_patterns << p1
+    pattern = Pattern.new :blank
+    test_patterns[:blank] = pattern
     
-    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
+    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"
+    test_patterns[:verse] = pattern
     
-    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
+    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."
+    test_patterns[:staircase] = pattern
     
     return test_patterns
   end
@@ -37,15 +37,15 @@ class PatternTest < Test::Unit::TestCase
   def test_initialize
     test_patterns = generate_test_data()
     
-    pattern = test_patterns.shift()
+    pattern = test_patterns[:blank]
     assert_equal(pattern.name, :blank)
     assert_equal(pattern.tracks.length, 0)
 
-    pattern = test_patterns.shift()
+    pattern = test_patterns[:verse]
     assert_equal(pattern.name, :verse)
     assert_equal(pattern.tracks.length, 4)
 
-    pattern = test_patterns.shift()
+    pattern = test_patterns[:staircase]
     assert_equal(pattern.name, :staircase)
     assert_equal(pattern.tracks.length, 3)
   end
@@ -54,21 +54,76 @@ class PatternTest < Test::Unit::TestCase
     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)
+    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[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)
+    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[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)
+    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
+    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())
+  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.")
+    
+    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.")
+    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...")
+    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.")
+    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.")
+    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.")
+    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,
@@ -84,7 +139,7 @@ class PatternTest < Test::Unit::TestCase
     test_patterns = generate_test_data()
     
     # Combined
-    test_patterns.each{|test_pattern|
+    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"])
@@ -93,61 +148,54 @@ class PatternTest < Test::Unit::TestCase
       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|
+      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
     }
-
-    #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|
+    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