trackler 2.0.8.51 → 2.0.8.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0528d77340cb5b9a9f02710c583d8b31db8d2669
-  data.tar.gz: 1db7cfbbbb6de5313ec61298d8f738f7173406d5
+  metadata.gz: 1b14ecd3a2ec9c1e8e23e8c7388b680666d46a2c
+  data.tar.gz: 9529b8cfff22f5305d62edfe36ac991781492715
 SHA512:
-  metadata.gz: 7deeb0de3270b5d18d9f71046f064e99bc806ffd8d4eb422e446a6fbb3361ea69707266a4e1ce28763ec1869a4d7fb84c53a4a9ff3b3bb9a96354a6491fc885c
-  data.tar.gz: a01de83dfdcf46d25ebcaf286db4bcdfc509310b0e91c9345207a6957e6ae0855286e739c4f7832264d86fbfbcd046c8ac38b8c8830d96193cfd597abde8a144
+  metadata.gz: 9fcb8b7b14ce2bdf9eb5313f27ba798944841ce731f3ad534c298f3aa839056aed656abe140bac617660701dbdbcdc8ee6a72bda2a3950443717e6feae29a8a7
+  data.tar.gz: 4a11526fc3a68fdd5d1632da3291d63b37a436b228e5679060849ff0129ce0a5de7f02750167e72894eb66a0eb4c6f2657c7ce3d250d3c1381f0011704aec1c3

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.51"
+  VERSION = "2.0.8.52"
 end

data/tracks/cpp/.editorconfig

@@ -0,0 +1,21 @@
+
+#Editor Config is So awesome
+
+#Indicate this is the config of the root
+root = true
+
+# Apply the following rules to these file types
+[{*.{cpp,cc,c,h,hpp,txt}}]
+end_of_line = lf                #Unix type line endings
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+#Separate Config for YML files
+[*.yml]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true

data/tracks/cpp/exercises/anagram/anagram_test.cpp

@@ -6,7 +6,8 @@ using namespace std;
 
 BOOST_AUTO_TEST_CASE(no_matches)
 {
-    auto subject = anagram::anagram("diaper");
+    // 'anagram::anagram' defines a class
+    anagram::anagram subject = anagram::anagram("diaper");
     auto matches = subject.matches({"hello", "world", "zombies", "pants"});
     vector<string> expected;
 

data/tracks/cpp/exercises/nucleotide-count/example.cpp

@@ -8,7 +8,11 @@ counter::counter(std::string const& sequence)
     : counts_({ {'A', 0}, {'C', 0}, {'G', 0}, {'T', 0} })
 {
     for (auto nucleotide : sequence) {
-        counts_[nucleotide]++;
+        auto it = counts_.find(nucleotide);
+        if (it == counts_.end()) {
+            throw std::invalid_argument("Unknown nucleotide");
+        }
+        ++(it->second);
     }
 }
 

data/tracks/cpp/exercises/nucleotide-count/nucleotide_count_test.cpp

@@ -62,6 +62,11 @@ BOOST_AUTO_TEST_CASE(validates_nucleotides)
     BOOST_REQUIRE_THROW(dna.count('X'), std::invalid_argument);
 }
 
+BOOST_AUTO_TEST_CASE(validates_nucleotides_on_construction)
+{
+    BOOST_REQUIRE_THROW(dna::counter("GGTTGGX"), std::invalid_argument);
+}
+
 BOOST_AUTO_TEST_CASE(counts_all_nucleotides)
 {
     const dna::counter dna("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC");

data/tracks/cpp/exercises/queen-attack/queen_attack_test.cpp

@@ -1,14 +1,15 @@
 #include "queen_attack.h"
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
-#include "require_equal_containers.h"
 
 BOOST_AUTO_TEST_CASE(queens_in_default_positions)
 {
     const queen_attack::chess_board board;
 
-    BOOST_REQUIRE_EQUAL(std::make_pair(0, 3), board.white());
-    BOOST_REQUIRE_EQUAL(std::make_pair(7, 3), board.black());
+    BOOST_REQUIRE_EQUAL(std::make_pair(0, 3).first, board.white().first);
+    BOOST_REQUIRE_EQUAL(std::make_pair(0, 3).second, board.white().second);
+    BOOST_REQUIRE_EQUAL(std::make_pair(7, 3).first, board.black().first);
+    BOOST_REQUIRE_EQUAL(std::make_pair(7, 3).second, board.black().second);
 }
 
 #if defined(EXERCISM_RUN_ALL_TESTS)
@@ -18,8 +19,10 @@ BOOST_AUTO_TEST_CASE(initialized_with_specific_positions)
     const auto black = std::make_pair(6, 1);
     const queen_attack::chess_board board{white, black};
 
-    BOOST_REQUIRE_EQUAL(white, board.white());
-    BOOST_REQUIRE_EQUAL(black, board.black());
+    BOOST_REQUIRE_EQUAL(white.first, board.white().first);
+    BOOST_REQUIRE_EQUAL(white.second, board.white().second);
+    BOOST_REQUIRE_EQUAL(black.first, board.black().first);
+    BOOST_REQUIRE_EQUAL(black.second, board.black().second);
 }
 
 BOOST_AUTO_TEST_CASE(queen_positions_must_be_distinct)

data/tracks/elixir/config.json

@@ -280,6 +280,14 @@
       "topics": [
       ]
     },
+    {
+      "slug": "scale-generator",
+      "difficulty": 5,
+      "topics": [
+        "enumerations",
+        "string processing"
+      ]
+    },
     {
       "slug": "luhn",
       "difficulty": 5,

data/tracks/elixir/exercises/hello-world/hello_world.exs

@@ -15,7 +15,7 @@ defmodule HelloWorld do
   function?
 
   Hint: look into argument defaults here:
-  http://elixir-lang.org/getting-started/modules.html#default-arguments
+  http://elixir-lang.org/getting-started/modules-and-functions.html#default-arguments
   """
 
   @doc """

data/tracks/elixir/exercises/scale-generator/example.exs

@@ -0,0 +1,119 @@
+defmodule ScaleGenerator do
+  @chromatic_scale ~w(C C# D D# E F F# G G# A A# B)
+  @flat_chromatic_scale ~w(C Db D Eb E F Gb G Ab A Bb B)
+  @flat_keys ~w(F Bb Eb Ab Db Gb d g c f bb eb)
+
+  @doc """
+  Find the note for a given interval (`step`) in a `scale` after the `tonic`.
+
+  "m": one semitone
+  "M": two semitones (full tone)
+  "A": augmented second (three semitones)
+
+  Given the `tonic` "D" in the `scale` (C C# D D# E F F# G G# A A# B C), you
+  should return the following notes for the given `step`:
+
+  "m": D#
+  "M": E
+  "A": F
+  """
+  @spec step(scale :: list(String.t()), tonic :: String.t(), step :: String.t()) :: list(String.t())
+  def step(scale, tonic, step) do
+    scale |> rotate_chromatic(tonic) |> do_step(step)
+  end
+
+  defp do_step([_tonic, semitone, _full_tone | _], "m"), do: semitone
+  defp do_step([_tonic, _semitone, full_tone | _], "M"), do: full_tone
+  defp do_step([_tonic, _semitone, _full_tone, accidental | _], "A"), do: accidental
+
+  @doc """
+  The chromatic scale is a musical scale with thirteen pitches, each a semitone
+  (half-tone) above or below another.
+
+  Notes with a sharp (#) are a semitone higher than the note below them, where
+  the next letter note is a full tone except in the case of B and E, which have
+  no sharps.
+
+  Generate these notes, starting with the given `tonic` and wrapping back
+  around to the note before it, ending with the tonic an octave higher than the
+  original. If the `tonic` is lowercase, capitalize it.
+
+  "C" should generate: ~w(C C# D D# E F F# G G# A A# B C)
+  """
+  @spec chromatic_scale(tonic :: String.t()) :: list(String.t())
+  def chromatic_scale(tonic \\ "C") do
+    rotate_chromatic(@chromatic_scale, tonic)
+  end
+
+  @doc """
+  Sharp notes can also be considered the flat (b) note of the tone above them,
+  so the notes can also be represented as:
+
+  A Bb B C Db D Eb E F Gb G Ab
+
+  Generate these notes, starting with the given `tonic` and wrapping back
+  around to the note before it, ending with the tonic an octave higher than the
+  original. If the `tonic` is lowercase, capitalize it.
+
+  "C" should generate: ~w(C Db D Eb E F Gb G Ab A Bb B C)
+  """
+  @spec flat_chromatic_scale(tonic :: String.t()) :: list(String.t())
+  def flat_chromatic_scale(tonic \\ "C") do
+    rotate_chromatic(@flat_chromatic_scale, tonic)
+  end
+
+  defp rotate_chromatic(scale, tonic) do
+    scale_length = length(scale)
+
+    scale
+    |> Stream.cycle
+    |> Enum.take(2 * scale_length)
+    |> rotate_chromatic(tonic |> String.capitalize, [])
+    |> Enum.take(scale_length + 1)
+  end
+  defp rotate_chromatic([tonic | _] = scale_from_tonic, tonic, results), do: scale_from_tonic ++ results
+  defp rotate_chromatic([head | tail], tonic, results), do: rotate_chromatic(tail, tonic, results ++ [head])
+
+  @doc """
+  Certain scales will require the use of the flat version, depending on the
+  `tonic` (key) that begins them, which is C in the above examples.
+
+  For any of the following tonics, use the flat chromatic scale:
+
+  F Bb Eb Ab Db Gb d g c f bb eb
+
+  For all others, use the regular chromatic scale.
+  """
+  @spec find_chromatic_scale(tonic :: String.t()) :: list(String.t())
+  for flat_tonic <- @flat_keys do
+    def find_chromatic_scale(unquote(flat_tonic)), do: flat_chromatic_scale(unquote(flat_tonic |> String.capitalize))
+  end
+  def find_chromatic_scale(tonic) do
+    chromatic_scale(tonic)
+  end
+
+  @doc """
+  The `pattern` string will let you know how many steps to make for the next
+  note in the scale.
+
+  For example, a C Major scale will receive the pattern "MMmMMMm", which
+  indicates you will start with C, make a full step over C# to D, another over
+  D# to E, then a semitone, stepping from E to F (again, E has no sharp). You
+  can follow the rest of the pattern to get:
+
+  C D E F G A B C
+  """
+  @spec scale(tonic :: String.t(), pattern :: String.t()) :: list(String.t())
+  def scale(tonic, pattern) do
+    tonic
+    |> find_chromatic_scale
+    |> generate_scale(pattern, [tonic |> String.capitalize])
+  end
+
+  defp generate_scale(scale, pattern, results)
+  defp generate_scale(_scale, "", results), do: Enum.reverse(results)
+  defp generate_scale(scale, <<step_amt::binary-size(1), pattern::binary>>, [last_tonic | _] = results) do
+    generate_scale(scale, pattern, [step(scale, last_tonic, step_amt) | results])
+  end
+end
+

data/tracks/elixir/exercises/scale-generator/scale_generator.exs

@@ -0,0 +1,83 @@
+defmodule ScaleGenerator do
+  @doc """
+  Find the note for a given interval (`step`) in a `scale` after the `tonic`.
+
+  "m": one semitone
+  "M": two semitones (full tone)
+  "A": augmented second (three semitones)
+
+  Given the `tonic` "D" in the `scale` (C C# D D# E F F# G G# A A# B C), you
+  should return the following notes for the given `step`:
+
+  "m": D#
+  "M": E
+  "A": F
+  """
+  @spec step(scale :: list(String.t()), tonic :: String.t(), step :: String.t()) :: list(String.t())
+  def step(scale, tonic, step) do
+  end
+
+  @doc """
+  The chromatic scale is a musical scale with thirteen pitches, each a semitone
+  (half-tone) above or below another.
+
+  Notes with a sharp (#) are a semitone higher than the note below them, where
+  the next letter note is a full tone except in the case of B and E, which have
+  no sharps.
+
+  Generate these notes, starting with the given `tonic` and wrapping back
+  around to the note before it, ending with the tonic an octave higher than the
+  original. If the `tonic` is lowercase, capitalize it.
+
+  "C" should generate: ~w(C C# D D# E F F# G G# A A# B C)
+  """
+  @spec chromatic_scale(tonic :: String.t()) :: list(String.t())
+  def chromatic_scale(tonic \\ "C") do
+  end
+
+  @doc """
+  Sharp notes can also be considered the flat (b) note of the tone above them,
+  so the notes can also be represented as:
+
+  A Bb B C Db D Eb E F Gb G Ab
+
+  Generate these notes, starting with the given `tonic` and wrapping back
+  around to the note before it, ending with the tonic an octave higher than the
+  original. If the `tonic` is lowercase, capitalize it.
+
+  "C" should generate: ~w(C Db D Eb E F Gb G Ab A Bb B C)
+  """
+  @spec flat_chromatic_scale(tonic :: String.t()) :: list(String.t())
+  def flat_chromatic_scale(tonic \\ "C") do
+  end
+
+  @doc """
+  Certain scales will require the use of the flat version, depending on the
+  `tonic` (key) that begins them, which is C in the above examples.
+
+  For any of the following tonics, use the flat chromatic scale:
+
+  F Bb Eb Ab Db Gb d g c f bb eb
+
+  For all others, use the regular chromatic scale.
+  """
+  @spec find_chromatic_scale(tonic :: String.t()) :: list(String.t())
+  def find_chromatic_scale(tonic) do
+  end
+
+  @doc """
+  The `pattern` string will let you know how many steps to make for the next
+  note in the scale.
+
+  For example, a C Major scale will receive the pattern "MMmMMMm", which
+  indicates you will start with C, make a full step over C# to D, another over
+  D# to E, then a semitone, stepping from E to F (again, E has no sharp). You
+  can follow the rest of the pattern to get:
+
+  C D E F G A B C
+  """
+  @spec scale(tonic :: String.t(), pattern :: String.t()) :: list(String.t())
+  def scale(tonic, pattern) do
+  end
+end
+

data/tracks/elixir/exercises/scale-generator/scale_generator_test.exs

@@ -0,0 +1,282 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("scale_generator.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure trace: true, exclude: :pending
+
+defmodule ScaleGeneratorTest do
+  use ExUnit.Case
+
+  @major_scale_pattern           "MMmMMMm"
+  @minor_scale_pattern           "MmMMmMM"
+  @dorian_scale_pattern          "MmMMMmM"
+  @mixolydian_scale_pattern      "MMmMMmM"
+  @lydian_scale_pattern          "MMMmMMm"
+  @phrygian_scale_pattern        "mMMMmMM"
+  @locrian_scale_pattern         "mMMmMMM"
+  @harmonic_minor_scale_pattern  "MmMMmAm"
+  @melodic_minor_scale_pattern   "MmMMMMm"
+  @octatonic_scale_pattern       "MmMmMmMm"
+  @hexatonic_scale_pattern       "MMMMMM"
+  @pentatonic_scale_pattern      "MMAMA"
+  @enigmatic_scale_pattern       "mAMMMmm"
+
+  describe "step to next note" do
+    #@tag :pending
+    test "with half-tone interval" do
+      assert ScaleGenerator.step(~w(C C# D D# E F F# G G# A A# B), "C", "m") == "C#"
+    end
+
+    @tag :pending
+    test "with full tone interval" do
+      assert ScaleGenerator.step(~w(C C# D D# E F F# G G# A A# B), "C", "M") == "D"
+    end
+
+    @tag :pending
+    test "with accidental interval" do
+      assert ScaleGenerator.step(~w(C C# D D# E F F# G G# A A# B), "C", "A") == "D#"
+    end
+  end
+
+  describe "generate chromatic scale" do
+    @tag :pending
+    test "starting with A" do
+      assert ScaleGenerator.chromatic_scale("A") == ~w(A A# B C C# D D# E F F# G G# A)
+    end
+
+    @tag :pending
+    test "starting with C" do
+      assert ScaleGenerator.chromatic_scale("C") == ~w(C C# D D# E F F# G G# A A# B C)
+    end
+
+    @tag :pending
+    test "starting with G" do
+      assert ScaleGenerator.chromatic_scale("G") == ~w(G G# A A# B C C# D D# E F F# G)
+    end
+
+    @tag :pending
+    test "works with with lowercase notes" do
+      assert ScaleGenerator.chromatic_scale("f#") == ~w(F# G G# A A# B C C# D D# E F F#)
+    end
+  end
+
+  describe "generate flat chromatic scale" do
+    @tag :pending
+    test "starting with A" do
+      assert ScaleGenerator.flat_chromatic_scale("A") == ~w(A Bb B C Db D Eb E F Gb G Ab A)
+    end
+
+    @tag :pending
+    test "starting with C" do
+      assert ScaleGenerator.flat_chromatic_scale("C") == ~w(C Db D Eb E F Gb G Ab A Bb B C)
+    end
+
+    @tag :pending
+    test "starting with G" do
+      assert ScaleGenerator.flat_chromatic_scale("G") == ~w(G Ab A Bb B C Db D Eb E F Gb G)
+    end
+
+    @tag :pending
+    test "works with with lowercase notes" do
+      assert ScaleGenerator.flat_chromatic_scale("Gb") == ~w(Gb G Ab A Bb B C Db D Eb E F Gb)
+    end
+  end
+
+  describe "find chromatic scale for flat tonics" do
+    @tag :pending
+    test "using F" do
+      assert ScaleGenerator.find_chromatic_scale("F") == ~w(F Gb G Ab A Bb B C Db D Eb E F)
+    end
+
+    @tag :pending
+    test "using Bb" do
+      assert ScaleGenerator.find_chromatic_scale("Bb") == ~w(Bb B C Db D Eb E F Gb G Ab A Bb)
+    end
+
+    @tag :pending
+    test "using Eb" do
+      assert ScaleGenerator.find_chromatic_scale("Eb") == ~w(Eb E F Gb G Ab A Bb B C Db D Eb)
+    end
+
+    @tag :pending
+    test "using Ab" do
+      assert ScaleGenerator.find_chromatic_scale("Ab") == ~w(Ab A Bb B C Db D Eb E F Gb G Ab)
+    end
+
+    @tag :pending
+    test "using Db" do
+      assert ScaleGenerator.find_chromatic_scale("Db") == ~w(Db D Eb E F Gb G Ab A Bb B C Db)
+    end
+
+    @tag :pending
+    test "using Gb" do
+      assert ScaleGenerator.find_chromatic_scale("Gb") == ~w(Gb G Ab A Bb B C Db D Eb E F Gb)
+    end
+
+    @tag :pending
+    test "using d" do
+      assert ScaleGenerator.find_chromatic_scale("d") == ~w(D Eb E F Gb G Ab A Bb B C Db D)
+    end
+
+    @tag :pending
+    test "using g" do
+      assert ScaleGenerator.find_chromatic_scale("g") == ~w(G Ab A Bb B C Db D Eb E F Gb  G)
+    end
+
+    @tag :pending
+    test "using c" do
+      assert ScaleGenerator.find_chromatic_scale("c") == ~w(C Db D Eb E F Gb G Ab A Bb B  C)
+    end
+
+    @tag :pending
+    test "using f" do
+      assert ScaleGenerator.find_chromatic_scale("f") == ~w(F Gb G Ab A Bb B C Db D Eb E F)
+    end
+
+    @tag :pending
+    test "using bb" do
+      assert ScaleGenerator.find_chromatic_scale("bb") == ~w(Bb B C Db D Eb E F Gb G Ab A Bb)
+    end
+
+    @tag :pending
+    test "using eb" do
+      assert ScaleGenerator.find_chromatic_scale("eb") == ~w(Eb E F Gb G Ab A Bb B C Db D Eb)
+    end
+  end
+
+  describe "find chromatic scale for non-flat tonics" do
+    @tag :pending
+    test "using A" do
+      assert ScaleGenerator.find_chromatic_scale("A") == ~w(A A# B C C# D D# E F F# G G# A)
+    end
+
+    @tag :pending
+    test "using A#" do
+      assert ScaleGenerator.find_chromatic_scale("A#") == ~w(A# B C C# D D# E F F# G G# A A#)
+    end
+
+    @tag :pending
+    test "using B" do
+      assert ScaleGenerator.find_chromatic_scale("B") == ~w(B C C# D D# E F F# G G# A A# B)
+    end
+
+    @tag :pending
+    test "using C" do
+      assert ScaleGenerator.find_chromatic_scale("C") == ~w(C C# D D# E F F# G G# A A# B C)
+    end
+
+    @tag :pending
+    test "using C#" do
+      assert ScaleGenerator.find_chromatic_scale("C#") == ~w(C# D D# E F F# G G# A A# B C C#)
+    end
+
+    @tag :pending
+    test "using D" do
+      assert ScaleGenerator.find_chromatic_scale("D") == ~w(D D# E F F# G G# A A# B C C# D)
+    end
+
+    @tag :pending
+    test "using D#" do
+      assert ScaleGenerator.find_chromatic_scale("D#") == ~w(D# E F F# G G# A A# B C C# D D#)
+    end
+
+    @tag :pending
+    test "using E" do
+      assert ScaleGenerator.find_chromatic_scale("E") == ~w(E F F# G G# A A# B C C# D D# E)
+    end
+
+    @tag :pending
+    test "using F#" do
+      assert ScaleGenerator.find_chromatic_scale("F#") == ~w(F# G G# A A# B C C# D D# E F F#)
+    end
+
+    @tag :pending
+    test "using G" do
+      assert ScaleGenerator.find_chromatic_scale("G") == ~w(G G# A A# B C C# D D# E F F# G)
+    end
+
+    @tag :pending
+    test "using G#" do
+      assert ScaleGenerator.find_chromatic_scale("G#") == ~w(G# A A# B C C# D D# E F F# G G#)
+    end
+  end
+
+  describe "generate scale from tonic and pattern" do
+    @tag :pending
+    test "C Major scale" do
+      assert ScaleGenerator.scale("C", @major_scale_pattern) == ~w(C D E F G A B C)
+    end
+
+    @tag :pending
+    test "G Major scale" do
+      assert ScaleGenerator.scale("G", @major_scale_pattern) == ~w(G A B C D E F# G)
+    end
+
+    @tag :pending
+    test "f# minor scale" do
+      assert ScaleGenerator.scale("f#", @minor_scale_pattern) == ~w(F# G# A B C# D E F#)
+    end
+
+    @tag :pending
+    test "b flat minor scale" do
+      assert ScaleGenerator.scale("bb", @minor_scale_pattern) == ~w(Bb C Db Eb F Gb Ab Bb)
+    end
+
+    @tag :pending
+    test "D Dorian scale" do
+      assert ScaleGenerator.scale("d", @dorian_scale_pattern) == ~w(D E F G A B C D)
+    end
+
+    @tag :pending
+    test "E flat Mixolydian scale" do
+      assert ScaleGenerator.scale("Eb", @mixolydian_scale_pattern) == ~w(Eb F G Ab Bb C Db Eb)
+    end
+
+    @tag :pending
+    test "a Lydian scale" do
+      assert ScaleGenerator.scale("a", @lydian_scale_pattern) == ~w(A B C# D# E F# G# A)
+    end
+
+    @tag :pending
+    test "e Phrygian scale" do
+      assert ScaleGenerator.scale("e", @phrygian_scale_pattern) == ~w(E F G A B C D E)
+    end
+
+    @tag :pending
+    test "g Locrian scale" do
+      assert ScaleGenerator.scale("g", @locrian_scale_pattern) == ~w(G Ab Bb C Db Eb F G)
+    end
+
+    @tag :pending
+    test "d Harmonic minor scale" do
+      assert ScaleGenerator.scale("d", @harmonic_minor_scale_pattern) == ~w(D E F G A Bb Db D)
+    end
+
+    @tag :pending
+    test "C Melodic minor scale" do
+      assert ScaleGenerator.scale("C", @melodic_minor_scale_pattern) == ~w(C D D# F G A B C)
+    end
+
+    @tag :pending
+    test "C Octatonic scale" do
+      assert ScaleGenerator.scale("C", @octatonic_scale_pattern) == ~w(C D D# F F# G# A B C)
+    end
+
+    @tag :pending
+    test "D flat Hexatonic scale" do
+      assert ScaleGenerator.scale("Db", @hexatonic_scale_pattern) == ~w(Db Eb F G A B Db)
+    end
+
+    @tag :pending
+    test "A Pentatonic scale" do
+      assert ScaleGenerator.scale("A", @pentatonic_scale_pattern) == ~w(A B C# E F# A)
+    end
+
+    @tag :pending
+    test "G Enigmatic scale" do
+      assert ScaleGenerator.scale("G", @enigmatic_scale_pattern) == ~w(G G# B C# D# F F# G)
+    end
+  end
+end
+