beats 2.1.1 → 2.1.2

data/test/fixtures/invalid/flow_repeat_count_is_missing_prefix.txt

@@ -0,0 +1,8 @@
+# Invalid song, since flow repeat count is missing the "x" prefix
+Song:
+  Tempo: 100
+  Flow:
+    - Verse:  2
+
+Verse:
+  - test/sounds/bass_mono_8.wav:  X...X...X...XX..X...X...XX..X...

data/test/fixtures/invalid/flow_section_not_a_string_or_hash.txt

@@ -0,0 +1,15 @@
+# Invalid song, since one of the flow sections is not a Hash
+Song:
+  Tempo: 100
+  Flow:
+  - Verse:  x2
+  - 6    # Invalid, since this is not a pattern name String, or a Hash
+  - Verse:  x2
+  - Chorus: x2
+
+
+Verse:
+  - test/sounds/bass_mono_8.wav:  X...X...
+
+Chorus:
+  - test/sounds/snare_mono_8.wav:  X...X...

data/test/fixtures/invalid/kit_filename_not_a_string.txt

@@ -0,0 +1,17 @@
+# Invalid song, the 'snare' Kit sound has an invalid filename
+Song:
+  Tempo: 120
+  Flow:
+    - Verse:   x2
+  Kit:
+    - bass:       test/sounds/bass_mono_8.wav
+    - snare:      3
+    - hh_closed:  test/sounds/hh_closed_mono_8.wav
+    - agogo:      test/sounds/agogo_high_mono_8.wav
+
+Verse:
+  - bass:       X...X...X...X...
+  - snare:      ..............X.
+  - hh_closed:  X.XXX.XX........
+  - hh_closed:  ........X.X.X.X.
+  - agogo:      ..............XX

data/test/fixtures/invalid/kit_not_an_array.txt

@@ -0,0 +1,17 @@
+# Invalid song, since the Kit is not an array (i.e., each line is not prefixed with "-")
+Song:
+  Tempo: 120
+  Flow:
+    - Verse:   x2
+  Kit:
+    bass:       ../../sounds/bass_mono_8.wav
+    snare:      ../../sounds/snare_mono_8.wav
+    hh_closed:  ../../sounds/hh_closed_mono_8.wav
+    agogo:      ../../sounds/agogo_high_mono_8.wav
+
+Verse:
+  - bass:       X...X...X...X...
+  - snare:      ..............X.
+  - hh_closed:  X.XXX.XX........
+  - hh_closed:  ........X.X.X.X.
+  - agogo:      ..............XX

data/test/fixtures/invalid/pattern_not_an_array.txt

@@ -0,0 +1,17 @@
+# Invalid song, since a Pattern is not an array (i.e., each line is not prefixed with "-")
+Song:
+  Tempo: 120
+  Flow:
+    - Verse:   x2
+  Kit:
+    - bass:       ../../sounds/bass_mono_8.wav
+    - snare:      ../../sounds/snare_mono_8.wav
+    - hh_closed:  ../../sounds/hh_closed_mono_8.wav
+    - agogo:      ../../sounds/agogo_high_mono_8.wav
+
+Verse:
+  bass:       X...X...X...X...
+  snare:      ..............X.
+  hh_closed:  X.XXX.XX........
+  hh_closed:  ........X.X.X.X.
+  agogo:      ..............XX

data/test/fixtures/invalid/pattern_referenced_pattern_name_not_a_string.txt

@@ -0,0 +1,19 @@
+# Invalid song, a pattern has a name which will not be parsed as a String, and it's referenced in the flow
+Song:
+  Tempo: 120
+  Flow:
+    - Verse: x2
+    - 4: x2
+  Kit:
+    - bass:       ../../sounds/bass_mono_8.wav
+    - snare:      ../../sounds/snare_mono_8.wav
+    - hh_closed:  ../../sounds/hh_closed_mono_8.wav
+    - agogo:      ../../sounds/agogo_high_mono_8.wav
+
+Verse:
+  - bass:       X...X...X...X...
+  - snare:      ..............X.
+
+4:   # Invalid pattern name!
+  - hh_closed:  X.XXX.XX........
+  - agogo:      ..............XX

data/test/fixtures/invalid/pattern_unreferenced_pattern_name_not_a_string.txt

@@ -0,0 +1,18 @@
+# Invalid song, a pattern has a name which will not be parsed as a String, but it's not referenced in the flow
+Song:
+  Tempo: 120
+  Flow:
+    - Verse: x2
+  Kit:
+    - bass:       ../../sounds/bass_mono_8.wav
+    - snare:      ../../sounds/snare_mono_8.wav
+    - hh_closed:  ../../sounds/hh_closed_mono_8.wav
+    - agogo:      ../../sounds/agogo_high_mono_8.wav
+
+Verse:
+  - bass:       X...X...X...X...
+  - snare:      ..............X.
+
+4:   # Invalid pattern name!
+  - hh_closed:  X.XXX.XX........
+  - agogo:      ..............XX

data/test/fixtures/invalid/pattern_with_incomplete_track.txt

@@ -0,0 +1,10 @@
+# Invalid song, since it contains a pattern with a track containing just a sound name not followed by a ":"
+
+Song:
+  Tempo: 100
+  Flow:
+    - Verse: x1
+
+Verse:
+  - test/sounds/bass_mono_8.wav:  X...X...
+  - test/sounds/snare_mono_8.wav

data/test/fixtures/invalid/pattern_with_nil_track.txt

@@ -0,0 +1,10 @@
+# Invalid song, since it contains a pattern with a nil track
+
+Song:
+  Tempo: 100
+  Flow:
+    - Verse: x1
+
+Verse:
+  - test/sounds/bass_mono_8.wav:  X...X...
+  -

data/test/fixtures/valid/composite_sounds_trailing_comma.txt

@@ -0,0 +1,16 @@
+Song:
+  Tempo: 100
+  Kit:
+    - bass:   test/sounds/bass_mono_8.wav
+    - snare:  [test/sounds/snare_mono_8.wav,]   # Trailing commas are valid in YAML
+    - hihat:  [test/sounds/hh_closed_mono_8.wav, test/sounds/hh_open_mono_8.wav,]
+  Flow:
+    - Verse:  x2
+    - Chorus: x2
+
+Verse:
+  - hihat:     X...X...
+  - [snare,]:  ..X...X.
+Chorus:
+  - bass:             XXXXXXXX
+  - [snare, hihat,]:  .X.X.X.X

data/test/fixtures/valid/example_alternate_array_syntax.txt

@@ -0,0 +1,11 @@
+# A song that uses alternate YAML syntax to define arrays.
+# This syntax is not recommended (in particular it's hard to read),
+# but it will be parsed as valid YAML.
+
+Song:
+  Tempo: 120
+  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]
+  Flow: [Verse: x2, Chorus: x2, Verse: x2, Chorus: x4]
+
+Verse: [bass: X...X...X...X..., snare: ....X.......X..., hhclosed: X.X.X.X.X.X.X..., hhopen: ..............X.]
+Chorus: [bass: X...X...XXXXXXXX, snare: X...X...X...X..., hhopen: ........X......., test/sounds/ride_mono_8.wav: ....X...........]

data/test/fixtures/valid/{multiple_song_header_sections.txt → multiple_copies_of_song_components.txt}

@@ -1,29 +1,53 @@
+# This example includes multiple copies of song components such as the Flow, Kit, etc.
+# In general, multiple copies of the same song component are allowed (due to the Song
+# header being a YAML hash), but the final definition should be chosen as the winner.
+
+
 # This song header is ignored, because it is overridden by a subsequent song
 # header at the end of the file
 Song:
-  Tempo: 100
+  Tempo: 90
   Flow:
     - Verse:   x1
     - Chorus:  x2
-    - Verse:   x1
-    - Chorus:  x2
   Kit:
     - bass:       test/sounds/bass_mono_8.wav
     - snare:      test/sounds/snare_mono_8.wav
 
 Verse:
   - bass:       X...X...X...X...
-  - snare:      ..............X.
 
 Chorus:
   - bass:       X...X...XX..X...
   - snare:      ....X.......X...
 
+
+
+
+
 # This is the actual song header that should be used
 Song:
+  Kit:
+    - bass2:   test/sounds/tom2_mono_8.wav
+    - snare2:  test/sounds/tom4_mono_8.wav
   Tempo: 200
+  Flow:
+    - Verse:  x4
   Flow:
     - Chorus:  x4
+  Tempo: 100
+  Tempo: 120
   Kit:
     - bass:   test/sounds/ride_mono_8.wav
     - snare:  test/sounds/snare2_mono_8.wav
+  Flow:
+    - Verse:   x2
+    - Chorus:  x2
+
+Verse:
+  - bass:       X.......X...X...
+  - snare:      ....X.......X...
+
+Chorus:
+  - bass:       X.X.X.X.X.X.X.X.
+  - snare:      X...X...X...X...

data/test/fixtures/valid/multiple_yaml_documents.txt

@@ -0,0 +1,33 @@
+# This file contains multiple YAML documents (demarcated by "---")
+# The first document should be chosen as the song to use, and the
+# second document should be ignored.
+
+---
+Song:
+  Tempo: 150
+  Flow:
+    - Verse: x2
+  Kit:
+    - bass:  test/sounds/bass_mono_8.wav
+
+Verse:
+  - bass: X...X...X...X...
+
+
+---
+Song:
+  Tempo: 200
+  Flow:
+    - Verse:  x3
+    - Chorus: x1
+  Kit:
+    - snare: test/sounds/snare_mono_8.wav
+    - tom:   test/sounds/tom4_mono_8.wav
+
+Verse:
+  - snare:  X...X...........
+  - tom:    ........X...X...
+
+Chorus:
+  - snare:  X.X.X.X.X.X.X.X.
+  - tom:    XXXXXXXXXXXXXXXX

data/test/fixtures/valid/track_sound_has_mixed_capitalization.txt

@@ -0,0 +1,13 @@
+# "MiXeD_CaPiTaLiZaTiOn.wav" should be the valid name for a track sound.
+# That is, there's no requirement that file names have all lowercase or uppercase letters.
+
+Song:
+  Tempo: 120
+  Flow:
+    - Verse: x1
+  Kit:
+    - bass:  test/sounds/MiXeD_CaPiTaLiZaTiOn.wav
+
+Verse:
+  - bass:                                  X...X...........
+  - test/sounds/MiXeD_CaPiTaLiZaTiOn.wav:  ........X...X...

data/test/includes.rb

@@ -1,3 +1,3 @@
-require 'minitest/autorun'
-require 'beats'
+require "minitest/autorun"
+require "beats"
 include Beats

data/test/integration_test.rb

@@ -1,4 +1,4 @@
-require 'includes'
+require "includes"
 
 class IntegrationTest < Minitest::Test
   TRACK_NAMES =  ["bass", "snare", "hh_closed", "hh_closed2", "agogo", "tom4", "tom2"]
@@ -11,8 +11,8 @@ class IntegrationTest < Minitest::Test
 
   def test_bad_song_errors
     invalid_fixtures = ["bad_tempo.txt",
-                        "bad_repeat_count.txt",
-                        "bad_flow.txt",
+                        "flow_invalid_repeat_count_suffix.txt",
+                        "flow_non_existent_pattern.txt",
                         "no_header.txt",
                         "no_flow.txt",
                         "sound_in_kit_not_found.txt",

data/test/kit_builder_test.rb

@@ -1,4 +1,4 @@
-require 'includes'
+require "includes"
 
 class KitBuilderTest < Minitest::Test
   def test_has_label?
@@ -43,8 +43,8 @@ class KitBuilderTest < Minitest::Test
     assert_equal(Kit, kit.class)
     assert_equal(2, kit.num_channels)
     assert_equal(16, kit.bits_per_sample)
-    assert_equal(Array, kit.get_sample_data('mono8').class)
-    assert_equal(Array, kit.get_sample_data('bass_mono_16.wav').class)
+    assert_equal(Array, kit.get_sample_data("mono8").class)
+    assert_equal(Array, kit.get_sample_data("bass_mono_16.wav").class)
   end
 
   def test_build_kit_no_sounds

data/test/kit_test.rb

@@ -1,21 +1,21 @@
-require 'includes'
+require "includes"
 
 class KitTest < Minitest::Test
   def test_kit_with_items
-    kit = Kit.new({'label1' => [1,2,3], 'label2' => [4,5,6], 'label3' => [7,8,9]}, 1, 16)
+    kit = Kit.new({"label1" => [1,2,3], "label2" => [4,5,6], "label3" => [7,8,9]}, 1, 16)
 
     assert_equal(["label1", "label2", "label3"], kit.labels)
-    assert_equal([1,2,3], kit.get_sample_data('label1'))
-    assert_equal([4,5,6], kit.get_sample_data('label2'))
-    assert_raises(Kit::LabelNotFoundError) { kit.get_sample_data('nope') }
-    assert_equal([7,8,9], kit.get_sample_data('label3'))
+    assert_equal([1,2,3], kit.get_sample_data("label1"))
+    assert_equal([4,5,6], kit.get_sample_data("label2"))
+    assert_raises(Kit::LabelNotFoundError) { kit.get_sample_data("nope") }
+    assert_equal([7,8,9], kit.get_sample_data("label3"))
   end
 
   def test_kit_with_no_items
     kit = Kit.new({}, 1, 16)
 
     assert_equal([], kit.labels)
-    assert_raises(Kit::LabelNotFoundError) { kit.get_sample_data('foo') }
+    assert_raises(Kit::LabelNotFoundError) { kit.get_sample_data("foo") }
   end
 
   def test_num_channels

data/test/pattern_test.rb

@@ -1,176 +1,176 @@
-require 'includes'
-
-class PatternTest < Minitest::Test
-  SAMPLE_RATE = 44100
-  SECONDS_IN_MINUTE = 60.0
-
-  def generate_test_data
-    test_patterns = {}
-
-    pattern = Pattern.new :blank
-    test_patterns[:blank] = pattern
-
-    verse_tracks = [
-      Track.new("bass.wav",      "X...X...X...XX..X...X...XX..X..."),
-      Track.new("snare.wav",     "..X...X...X...X.X...X...X...X..."),
-      Track.new("hh_closed.wav", "X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X."),
-      Track.new("hh_open.wav",   "X...............X..............X"),
-    ]
-    pattern = Pattern.new(:verse, verse_tracks)
-    test_patterns[:verse] = pattern
-
-    staircase_tracks = [
-      Track.new("bass.wav",      "X..."),
-      Track.new("snare.wav",     "X.."),
-      Track.new("hh_closed.wav", "X."),
-    ]
-    pattern = Pattern.new(:staircase, staircase_tracks)
-    test_patterns[:staircase] = pattern
-
-    test_patterns
-  end
-
-  def test_initialize
-    test_patterns = generate_test_data
-
-    pattern = test_patterns[:blank]
-    assert_equal(pattern.name, :blank)
-    assert_equal(pattern.tracks.length, 0)
-
-    pattern = test_patterns[:verse]
-    assert_equal(pattern.name, :verse)
-    assert_equal(pattern.tracks.length, 4)
-
-    pattern = test_patterns[:staircase]
-    assert_equal(pattern.name, :staircase)
-    assert_equal(pattern.tracks.length, 3)
-
-    tracks = [
-      Track.new("track1", "X...X..."),
-      Track.new("track2", "X..."),
-    ]
-    pattern = Pattern.new(:tracks_provided_in_constructor, tracks)
-    assert_equal(pattern.name, :tracks_provided_in_constructor)
-    assert_equal(pattern.tracks.length, 2)
-    assert_pattern_tracks(pattern, {"track1" => {name: "track1", rhythm: "X...X..."},
-                                    "track2" => {name: "track2",  rhythm: "X......."}})
-
-    tracks = [
-      Track.new("my_sound", "X...X..."),
-      Track.new("my_other_sound", "X..."),
-      Track.new("my_sound", ".X.........."),
-      Track.new("my_sound2", "..X........."),
-      Track.new("my_sound", ".."),
-    ]
-    pattern = Pattern.new("whatevs", tracks)
-
-    assert_pattern_tracks(pattern, {"my_sound"       => {name: "my_sound",       rhythm: "X...X......."},
-                                    "my_other_sound" => {name: "my_other_sound", rhythm: "X..........."},
-                                    "my_sound2"      => {name: "my_sound",       rhythm: ".X.........."},
-                                    "my_sound22"     => {name: "my_sound2",      rhythm: "..X........."},
-                                    "my_sound3"      => {name: "my_sound",       rhythm: "............"},})
-  end
-
-  def test_track_array_is_frozen
-    tracks = [
-      Track.new("my_sound1", "X...X..."),
-      Track.new("my_sound2", "X.X.X.X."),
-      Track.new("my_sound3", "XXXXXXXX"),
-    ]
-    pattern = Pattern.new("whatevs", tracks)
-
-    assert_raises(RuntimeError) { pattern.tracks["my_sound4"] = Track.new("my_sound4", "X...X...") }
-  end
-
-  def test_track_unique_name_already_taken
-    tracks = [
-      Track.new("my_sound2", "X...X..."),
-      Track.new("my_sound",  "X.X.X.X."),
-      Track.new("my_sound",  "XXXXXXXX"),
-    ]
-    pattern = Pattern.new("whatevs", tracks)
-
-    assert_pattern_tracks(pattern, {"my_sound2" => {name: "my_sound2", rhythm: "X...X..."},
-                                    "my_sound"  => {name: "my_sound",  rhythm: "X.X.X.X."},
-                                    # The first attempt at a unique name would be "my_sound2", but that is already taken
-                                    "my_sound3" => {name: "my_sound",  rhythm: "XXXXXXXX"}})
-  end
-
-  def test_step_count
-    test_patterns = generate_test_data
-
-    assert_equal(0,  test_patterns[:blank].step_count)
-    assert_equal(32, test_patterns[:verse].step_count)
-    assert_equal(4,  test_patterns[:staircase].step_count)
-  end
-
-  def test_same_tracks_as?
-    left_tracks = [
-      Track.new("bass",      "X...X..."),
-      Track.new("snare",     "..X...X."),
-      Track.new("hh_closed", "X.X.X.X."),
-    ]
-    left_pattern = Pattern.new("left", left_tracks)
-
-    right_tracks = [
-      Track.new("bass",      "X...X..."),
-      Track.new("snare",     "..X...X."),
-      Track.new("hh_closed", "X.X.X.X."),
-    ]
-    right_pattern = Pattern.new("right", right_tracks)
-    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_tracks = [
-      Track.new("snare",     "..X...X."),
-      Track.new("hh_closed", "X.X.X.X."),
-      Track.new("bass",      "X...X..."),
-    ]
-    right_pattern = Pattern.new("right", right_tracks)
-    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_tracks = [
-      Track.new("tom",     "X...X..."),
-      Track.new("cymbal",  "..X...X."),
-      Track.new("hh_open", "X.X.X.X."),
-    ]
-    different_names_pattern = Pattern.new("different_names", different_names_tracks)
-    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_tracks = [
-      Track.new("bass",      "X...X..."),
-      Track.new("snare",     "..X...X."),
-      Track.new("hh_closed", "X.XXX.X."),
-    ]
-    different_beats_pattern = Pattern.new("different_beats", different_beats_tracks)
-    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_tracks = [
-      Track.new("bass",      "X...X..."),
-      Track.new("snare",     "..X...X."),
-      Track.new("hh_closed", "X.X.X.X."),
-      Track.new("extra",     "X..X..X."),
-    ]
-    something_extra = Pattern.new("something_extra", something_extra_tracks)
-    assert_equal(false, left_pattern.same_tracks_as?(something_extra))
-    assert_equal(false, something_extra.same_tracks_as?(left_pattern))
-  end
-
-  private
-
-  def assert_pattern_tracks(pattern, expected_pattern_structure)
-    assert_equal(expected_pattern_structure.keys, pattern.tracks.keys)
-
-    expected_pattern_structure.each do |pattern_key, expected_track|
-      assert_equal(expected_track[:name],   pattern.tracks[pattern_key].name)
-      assert_equal(expected_track[:rhythm], pattern.tracks[pattern_key].rhythm)
-    end
-  end
-end
+require "includes"
+
+class PatternTest < Minitest::Test
+  SAMPLE_RATE = 44100
+  SECONDS_IN_MINUTE = 60.0
+
+  def generate_test_data
+    test_patterns = {}
+
+    pattern = Pattern.new :blank
+    test_patterns[:blank] = pattern
+
+    verse_tracks = [
+      Track.new("bass.wav",      "X...X...X...XX..X...X...XX..X..."),
+      Track.new("snare.wav",     "..X...X...X...X.X...X...X...X..."),
+      Track.new("hh_closed.wav", "X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X."),
+      Track.new("hh_open.wav",   "X...............X..............X"),
+    ]
+    pattern = Pattern.new(:verse, verse_tracks)
+    test_patterns[:verse] = pattern
+
+    staircase_tracks = [
+      Track.new("bass.wav",      "X..."),
+      Track.new("snare.wav",     "X.."),
+      Track.new("hh_closed.wav", "X."),
+    ]
+    pattern = Pattern.new(:staircase, staircase_tracks)
+    test_patterns[:staircase] = pattern
+
+    test_patterns
+  end
+
+  def test_initialize
+    test_patterns = generate_test_data
+
+    pattern = test_patterns[:blank]
+    assert_equal(pattern.name, :blank)
+    assert_equal(pattern.tracks.length, 0)
+
+    pattern = test_patterns[:verse]
+    assert_equal(pattern.name, :verse)
+    assert_equal(pattern.tracks.length, 4)
+
+    pattern = test_patterns[:staircase]
+    assert_equal(pattern.name, :staircase)
+    assert_equal(pattern.tracks.length, 3)
+
+    tracks = [
+      Track.new("track1", "X...X..."),
+      Track.new("track2", "X..."),
+    ]
+    pattern = Pattern.new(:tracks_provided_in_constructor, tracks)
+    assert_equal(pattern.name, :tracks_provided_in_constructor)
+    assert_equal(pattern.tracks.length, 2)
+    assert_pattern_tracks(pattern, {"track1" => {name: "track1", rhythm: "X...X..."},
+                                    "track2" => {name: "track2",  rhythm: "X......."}})
+
+    tracks = [
+      Track.new("my_sound", "X...X..."),
+      Track.new("my_other_sound", "X..."),
+      Track.new("my_sound", ".X.........."),
+      Track.new("my_sound2", "..X........."),
+      Track.new("my_sound", ".."),
+    ]
+    pattern = Pattern.new("whatevs", tracks)
+
+    assert_pattern_tracks(pattern, {"my_sound"       => {name: "my_sound",       rhythm: "X...X......."},
+                                    "my_other_sound" => {name: "my_other_sound", rhythm: "X..........."},
+                                    "my_sound2"      => {name: "my_sound",       rhythm: ".X.........."},
+                                    "my_sound22"     => {name: "my_sound2",      rhythm: "..X........."},
+                                    "my_sound3"      => {name: "my_sound",       rhythm: "............"},})
+  end
+
+  def test_track_array_is_frozen
+    tracks = [
+      Track.new("my_sound1", "X...X..."),
+      Track.new("my_sound2", "X.X.X.X."),
+      Track.new("my_sound3", "XXXXXXXX"),
+    ]
+    pattern = Pattern.new("whatevs", tracks)
+
+    assert_raises(RuntimeError) { pattern.tracks["my_sound4"] = Track.new("my_sound4", "X...X...") }
+  end
+
+  def test_track_unique_name_already_taken
+    tracks = [
+      Track.new("my_sound2", "X...X..."),
+      Track.new("my_sound",  "X.X.X.X."),
+      Track.new("my_sound",  "XXXXXXXX"),
+    ]
+    pattern = Pattern.new("whatevs", tracks)
+
+    assert_pattern_tracks(pattern, {"my_sound2" => {name: "my_sound2", rhythm: "X...X..."},
+                                    "my_sound"  => {name: "my_sound",  rhythm: "X.X.X.X."},
+                                    # The first attempt at a unique name would be "my_sound2", but that is already taken
+                                    "my_sound3" => {name: "my_sound",  rhythm: "XXXXXXXX"}})
+  end
+
+  def test_step_count
+    test_patterns = generate_test_data
+
+    assert_equal(0,  test_patterns[:blank].step_count)
+    assert_equal(32, test_patterns[:verse].step_count)
+    assert_equal(4,  test_patterns[:staircase].step_count)
+  end
+
+  def test_same_tracks_as?
+    left_tracks = [
+      Track.new("bass",      "X...X..."),
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.X.X.X."),
+    ]
+    left_pattern = Pattern.new("left", left_tracks)
+
+    right_tracks = [
+      Track.new("bass",      "X...X..."),
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.X.X.X."),
+    ]
+    right_pattern = Pattern.new("right", right_tracks)
+    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_tracks = [
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.X.X.X."),
+      Track.new("bass",      "X...X..."),
+    ]
+    right_pattern = Pattern.new("right", right_tracks)
+    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_tracks = [
+      Track.new("tom",     "X...X..."),
+      Track.new("cymbal",  "..X...X."),
+      Track.new("hh_open", "X.X.X.X."),
+    ]
+    different_names_pattern = Pattern.new("different_names", different_names_tracks)
+    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_tracks = [
+      Track.new("bass",      "X...X..."),
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.XXX.X."),
+    ]
+    different_beats_pattern = Pattern.new("different_beats", different_beats_tracks)
+    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_tracks = [
+      Track.new("bass",      "X...X..."),
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.X.X.X."),
+      Track.new("extra",     "X..X..X."),
+    ]
+    something_extra = Pattern.new("something_extra", something_extra_tracks)
+    assert_equal(false, left_pattern.same_tracks_as?(something_extra))
+    assert_equal(false, something_extra.same_tracks_as?(left_pattern))
+  end
+
+  private
+
+  def assert_pattern_tracks(pattern, expected_pattern_structure)
+    assert_equal(expected_pattern_structure.keys, pattern.tracks.keys)
+
+    expected_pattern_structure.each do |pattern_key, expected_track|
+      assert_equal(expected_track[:name],   pattern.tracks[pattern_key].name)
+      assert_equal(expected_track[:rhythm], pattern.tracks[pattern_key].rhythm)
+    end
+  end
+end