rkoans 0.0.1 → 0.1.0

data/test/exercises/about_sandwich_code_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+require ARGV.shift
+
+require 'tempfile'
+
+class AboutSandwichCodeTest < Minitest::Test
+  # Count and search the original example through each version of the operation.
+  def test_counting_and_finding_lines
+    Tempfile.create('rkoans-lines') do |file|
+      file.write("this\nis\na\ntest\n")
+      file.flush
+      subject = Exercises::AboutSandwichCode
+
+      assert_equal 4, subject.count_lines(file.path)
+      assert_equal 4, subject.count_lines2(file.path)
+      assert_equal 4, subject.count_lines3(file.path)
+      assert_equal "test\n", subject.find_line(file.path)
+      assert_equal "test\n", subject.find_line2(file.path)
+    end
+  end
+
+  # Empty files, absent matches and a final unterminated line retain their meaning.
+  def test_empty_and_unterminated_files
+    Tempfile.create('rkoans-lines') do |file|
+      subject = Exercises::AboutSandwichCode
+
+      assert_equal 0, subject.count_lines2(file.path)
+      assert_nil subject.find_line2(file.path)
+      file.write('ruby')
+      file.flush
+
+      assert_equal 1, subject.count_lines3(file.path)
+      assert_nil subject.find_line2(file.path)
+    end
+  end
+
+  # The resource closes and the result survives both successful and failing blocks.
+  def test_file_sandwich_closes_on_success_and_exception
+    Tempfile.create('rkoans-cleanup') do |file|
+      captured = nil
+      result = Exercises::AboutSandwichCode.file_sandwich(file.path) do |opened|
+        captured = opened
+        :result
+      end
+
+      assert_equal :result, result
+      assert_predicate captured, :closed?
+      error = assert_raises(RuntimeError) do
+        Exercises::AboutSandwichCode.file_sandwich(file.path) do |opened|
+          captured = opened
+          raise 'operation failed'
+        end
+      end
+
+      assert_equal 'operation failed', error.message
+      assert_predicate captured, :closed?
+    ensure
+      captured&.close
+    end
+  end
+
+  # A block's early break must also release the open file.
+  def test_file_sandwich_closes_on_early_exit
+    Tempfile.create('rkoans-cleanup') do |file|
+      captured = nil
+      result = Exercises::AboutSandwichCode.file_sandwich(file.path) do |opened|
+        captured = opened
+        break :early
+      end
+
+      assert_equal :early, result
+      assert_predicate captured, :closed?
+    ensure
+      captured&.close
+    end
+  end
+end

data/test/exercises/about_scope_test.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# An empty class demonstrates construction without custom methods.
+# Class identity comparisons explicitly demonstrate lexical constant lookup.
+# rubocop:disable Lint/EmptyClass, Style/ClassEqualityComparison
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+require ARGV.shift
+class AboutScopeTest < Minitest::Test
+  module Jims
+    class Dog
+      # Demonstrates identify.
+      def identify
+        :jims_dog
+      end
+    end
+  end
+
+  module Joes
+    class Dog
+      # Demonstrates identify.
+      def identify
+        :joes_dog
+      end
+    end
+  end
+
+  # Checks dog is not available in the current scope.
+  def test_dog_is_not_available_in_the_current_scope
+    assert_predicted_error(:dog_is_not_available_in_the_current_scope_one, ::NameError) do
+      Dog.new
+    end
+  end
+
+  # Checks you can reference nested classes using the scope operator.
+  def test_you_can_reference_nested_classes_using_the_scope_operator
+    fido = Jims::Dog.new
+    rover = Joes::Dog.new
+
+    assert_equal Exercises::AboutScope.koans.fetch(:you_can_reference_nested_classes_using_the_scope_operator_one),
+                 fido.identify
+    assert_equal Exercises::AboutScope.koans.fetch(:you_can_reference_nested_classes_using_the_scope_operator_two),
+                 rover.identify
+
+    assert_equal Exercises::AboutScope.koans.fetch(:you_can_reference_nested_classes_using_the_scope_operator_three),
+                 (fido.class != rover.class)
+    assert_equal Exercises::AboutScope.koans.fetch(:you_can_reference_nested_classes_using_the_scope_operator_four),
+                 (Jims::Dog != Joes::Dog)
+  end
+
+  # ------------------------------------------------------------------
+
+  class String
+  end
+
+  # Checks bare bones class names assume the current scope.
+  def test_bare_bones_class_names_assume_the_current_scope
+    assert_equal Exercises::AboutScope.koans.fetch(:bare_bones_class_names_assume_the_current_scope_one),
+                 (AboutScopeTest::String == String)
+  end
+
+  # Checks nested string is not the same as the system string.
+  def test_nested_string_is_not_the_same_as_the_system_string
+    assert_equal Exercises::AboutScope.koans.fetch(:nested_string_is_not_the_same_as_the_system_string_one),
+                 ('HI'.class == String)
+  end
+
+  # Checks use the prefix scope operator to force the global scope.
+  def test_use_the_prefix_scope_operator_to_force_the_global_scope
+    assert_equal Exercises::AboutScope.koans.fetch(:use_the_prefix_scope_operator_to_force_the_global_scope_one),
+                 ('HI'.class == ::String)
+  end
+
+  # ------------------------------------------------------------------
+
+  PI = 3.1416
+
+  # Checks constants are defined with an initial uppercase letter.
+  def test_constants_are_defined_with_an_initial_uppercase_letter
+    assert_equal Exercises::AboutScope.koans.fetch(:constants_are_defined_with_an_initial_uppercase_letter_one), PI
+  end
+
+  # ------------------------------------------------------------------
+
+  MyString = ::String
+
+  # Checks class names are just constants.
+  def test_class_names_are_just_constants
+    assert_equal Exercises::AboutScope.koans.fetch(:class_names_are_just_constants_one), (MyString == ::String)
+    assert_equal Exercises::AboutScope.koans.fetch(:class_names_are_just_constants_two), ('HI'.class == MyString)
+  end
+
+  # Checks constants can be looked up explicitly.
+  def test_constants_can_be_looked_up_explicitly
+    assert_equal Exercises::AboutScope.koans.fetch(:constants_can_be_looked_up_explicitly_one),
+                 (AboutScopeTest.const_get('PI') == PI)
+    assert_equal Exercises::AboutScope.koans.fetch(:constants_can_be_looked_up_explicitly_two),
+                 (AboutScopeTest.const_get('MyString') == MyString)
+  end
+
+  # Checks you can get a list of constants for any class or module.
+  def test_you_can_get_a_list_of_constants_for_any_class_or_module
+    assert_equal Exercises::AboutScope.koans.fetch(:you_can_get_a_list_of_constants_for_any_class_or_module_one),
+                 Jims.constants
+    assert_equal Exercises::AboutScope.koans.fetch(:you_can_get_a_list_of_constants_for_any_class_or_module_two),
+                 Object.constants.any?
+  end
+
+  # Checks the predicted exception class while returning the captured error.
+  # @param key [Symbol] answer field
+  # @param klass [Class<Exception>] exception raised by the example
+  # @return [Exception]
+  def assert_predicted_error(key, ...)
+    error = assert_raises(...)
+    assert_equal Exercises::AboutScope.koans.fetch(key), error.class
+    error
+  end
+end
+
+# rubocop:enable Lint/EmptyClass, Style/ClassEqualityComparison

data/test/exercises/about_scoring_project_test.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+# Preserve the original descriptive Koans check names.
+# rubocop:disable Naming/VariableNumber
+
+require ARGV.shift
+
+class AboutScoringProjectTest < Minitest::Test
+  # Checks score of an empty list is zero.
+  def test_score_of_an_empty_list_is_zero
+    assert_equal 0, Exercises::AboutScoringProject.score([])
+  end
+
+  # Checks score of a single roll of 5 is 50.
+  def test_score_of_a_single_roll_of_5_is_50
+    assert_equal 50, Exercises::AboutScoringProject.score([5])
+  end
+
+  # Checks score of a single roll of 1 is 100.
+  def test_score_of_a_single_roll_of_1_is_100
+    assert_equal 100, Exercises::AboutScoringProject.score([1])
+  end
+
+  # Checks score of multiple 1s and 5s is the sum of individual scores.
+  def test_score_of_multiple_1s_and_5s_is_the_sum_of_individual_scores
+    assert_equal 300, Exercises::AboutScoringProject.score([1, 5, 5, 1])
+  end
+
+  # Checks score of single 2s 3s 4s and 6s are zero.
+  def test_score_of_single_2s_3s_4s_and_6s_are_zero
+    assert_equal 0, Exercises::AboutScoringProject.score([2, 3, 4, 6])
+  end
+
+  # Checks score of a triple 1 is 1000.
+  def test_score_of_a_triple_1_is_1000
+    assert_equal 1000, Exercises::AboutScoringProject.score([1, 1, 1])
+  end
+
+  # Checks score of other triples is 100x.
+  def test_score_of_other_triples_is_100x
+    assert_equal 200, Exercises::AboutScoringProject.score([2, 2, 2])
+    assert_equal 300, Exercises::AboutScoringProject.score([3, 3, 3])
+    assert_equal 400, Exercises::AboutScoringProject.score([4, 4, 4])
+    assert_equal 500, Exercises::AboutScoringProject.score([5, 5, 5])
+    assert_equal 600, Exercises::AboutScoringProject.score([6, 6, 6])
+  end
+
+  # Checks score of mixed is sum.
+  def test_score_of_mixed_is_sum
+    assert_equal 250, Exercises::AboutScoringProject.score([2, 5, 2, 2, 3])
+    assert_equal 550, Exercises::AboutScoringProject.score([5, 5, 5, 5])
+    assert_equal 1100, Exercises::AboutScoringProject.score([1, 1, 1, 1])
+    assert_equal 1200, Exercises::AboutScoringProject.score([1, 1, 1, 1, 1])
+    assert_equal 1150, Exercises::AboutScoringProject.score([1, 1, 1, 5, 1])
+  end
+end
+
+# rubocop:enable Naming/VariableNumber

data/test/exercises/about_strings_test.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: false
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+# Literal quoting and character syntax are the subjects of these examples.
+# Mutable literals also preserve the original mutation and identity experiments.
+# rubocop:disable Style/StringLiterals, Style/PercentLiteralDelimiters, Style/CharacterLiteral
+# rubocop:disable Style/StringConcatenation, Lint/UselessAssignment, Lint/InterpolationCheck
+# rubocop:disable Minitest/LiteralAsActualArgument, Style/RedundantRegexpArgument, Lint/IdentityComparison
+require ARGV.shift
+
+class AboutStringsQuotingTest < Minitest::Test
+  # Checks double quoted strings are strings.
+  def test_double_quoted_strings_are_strings
+    string = "Hello, World"
+
+    assert_equal Exercises::AboutStrings.koans[:double_quoted_string], string.is_a?(String)
+  end
+
+  # Checks single quoted strings are also strings.
+  def test_single_quoted_strings_are_also_strings
+    string = 'Goodbye, World'
+
+    assert_equal Exercises::AboutStrings.koans[:single_quoted_string], string.is_a?(String)
+  end
+
+  # Checks use single quotes to create string with double quotes.
+  def test_use_single_quotes_to_create_string_with_double_quotes
+    string = 'He said, "Go Away."'
+
+    assert_equal Exercises::AboutStrings.koans[:quoted_speech], string
+  end
+
+  # Checks use double quotes to create strings with single quotes.
+  def test_use_double_quotes_to_create_strings_with_single_quotes
+    string = "Don't"
+
+    assert_equal Exercises::AboutStrings.koans[:apostrophe], string
+  end
+
+  # Checks use backslash for those hard cases.
+  def test_use_backslash_for_those_hard_cases
+    a = "He said, \"Don't\""
+    b = 'He said, "Don\'t"'
+
+    assert_equal Exercises::AboutStrings.koans[:escaped_quotes_equal], a == b
+  end
+
+  # Checks use flexible quoting to handle really hard cases.
+  def test_use_flexible_quoting_to_handle_really_hard_cases
+    a = %(flexible quotes can handle both ' and " characters)
+    b = %!flexible quotes can handle both ' and " characters!
+    c = %{flexible quotes can handle both ' and " characters}
+
+    assert_equal Exercises::AboutStrings.koans[:flexible_percent_equal], a == b
+    assert_equal Exercises::AboutStrings.koans[:flexible_braces_equal], a == c
+  end
+
+  # Checks flexible quotes can handle multiple lines.
+  def test_flexible_quotes_can_handle_multiple_lines
+    long_string = %{
+It was the best of times,
+It was the worst of times.
+}
+
+    assert_equal Exercises::AboutStrings.koans[:multiline_length], long_string.length
+    assert_equal Exercises::AboutStrings.koans[:multiline_lines], long_string.lines.count
+    assert_equal Exercises::AboutStrings.koans[:multiline_first_character], long_string[0, 1]
+  end
+
+  # Checks here documents can also handle multiple lines.
+  def test_here_documents_can_also_handle_multiple_lines
+    long_string = <<~TEXT
+      It was the best of times,
+      It was the worst of times.
+    TEXT
+    assert_equal Exercises::AboutStrings.koans[:heredoc_length], long_string.length
+    assert_equal Exercises::AboutStrings.koans[:heredoc_lines], long_string.lines.count
+    assert_equal Exercises::AboutStrings.koans[:heredoc_first_character], long_string[0, 1]
+  end
+end
+
+class AboutStringsMutationTest < Minitest::Test
+  # Checks plus will concatenate two strings.
+  def test_plus_will_concatenate_two_strings
+    string = "Hello, " + "World"
+
+    assert_equal Exercises::AboutStrings.koans[:concatenated], string
+  end
+
+  # Checks plus concatenation will leave the original strings unmodified.
+  def test_plus_concatenation_will_leave_the_original_strings_unmodified
+    hi = "Hello, "
+    there = "World"
+    string = hi + there
+
+    assert_equal Exercises::AboutStrings.koans[:plus_original], hi
+    assert_equal Exercises::AboutStrings.koans[:plus_other], there
+  end
+
+  # Checks plus equals will concatenate to the end of a string.
+  def test_plus_equals_will_concatenate_to_the_end_of_a_string
+    hi = "Hello, "
+    there = "World"
+    hi += there
+
+    assert_equal Exercises::AboutStrings.koans[:plus_equals_result], hi
+  end
+
+  # Checks plus equals also will leave the original string unmodified.
+  def test_plus_equals_also_will_leave_the_original_string_unmodified
+    original_string = "Hello, "
+    hi = original_string
+    there = "World"
+    hi += there
+
+    assert_equal Exercises::AboutStrings.koans[:plus_equals_original], original_string
+  end
+
+  # Checks the shovel operator will also append content to a string.
+  def test_the_shovel_operator_will_also_append_content_to_a_string
+    hi = "Hello, "
+    there = "World"
+    hi << there
+
+    assert_equal Exercises::AboutStrings.koans[:append_result], hi
+    assert_equal Exercises::AboutStrings.koans[:append_other], there
+  end
+
+  # Checks the shovel operator modifies the original string.
+  def test_the_shovel_operator_modifies_the_original_string
+    original_string = "Hello, "
+    hi = original_string
+    there = "World"
+    hi << there
+
+    assert_equal Exercises::AboutStrings.koans[:appended_original], original_string
+
+    # THINK ABOUT IT:
+    #
+    # Ruby programmers tend to favor the shovel operator (<<) over the
+    # plus equals operator (+=) when building up strings.  Why?
+  end
+end
+
+class AboutStringsValuesTest < Minitest::Test
+  # Checks double quoted string interpret escape characters.
+  def test_double_quoted_string_interpret_escape_characters
+    string = "\n"
+
+    assert_equal Exercises::AboutStrings.koans[:double_escape_length], string.size
+  end
+
+  # Checks single quoted string do not interpret escape characters.
+  def test_single_quoted_string_do_not_interpret_escape_characters
+    string = '\n'
+
+    assert_equal Exercises::AboutStrings.koans[:single_escape_length], string.size
+  end
+
+  # Checks single quotes sometimes interpret escape characters.
+  def test_single_quotes_sometimes_interpret_escape_characters
+    string = '\\\''
+
+    assert_equal Exercises::AboutStrings.koans[:quote_escape_length], string.size
+    assert_equal Exercises::AboutStrings.koans[:quote_escape_text], string
+  end
+
+  # Checks double quoted strings interpolate variables.
+  def test_double_quoted_strings_interpolate_variables
+    value = 123
+    string = "The value is #{value}"
+
+    assert_equal Exercises::AboutStrings.koans[:interpolated], string
+  end
+
+  # Checks single quoted strings do not interpolate.
+  def test_single_quoted_strings_do_not_interpolate
+    value = 123
+    string = 'The value is #{value}'
+
+    assert_equal Exercises::AboutStrings.koans[:not_interpolated], string
+  end
+
+  # Checks any ruby expression may be interpolated.
+  def test_any_ruby_expression_may_be_interpolated
+    string = "The square root of 5 is #{Math.sqrt(5)}"
+
+    assert_equal Exercises::AboutStrings.koans[:math_interpolation], string
+  end
+
+  # Checks you can get a substring from a string.
+  def test_you_can_get_a_substring_from_a_string
+    string = "Bacon, lettuce and tomato"
+
+    assert_equal Exercises::AboutStrings.koans[:substring_slice], string[7, 3]
+    assert_equal Exercises::AboutStrings.koans[:substring_range], string[7..9]
+  end
+
+  # Checks you can get a single character from a string.
+  def test_you_can_get_a_single_character_from_a_string
+    string = "Bacon, lettuce and tomato"
+
+    assert_equal Exercises::AboutStrings.koans[:single_character], string[1]
+
+    # Surprised?
+  end
+
+  # Checks in modern ruby single characters are represented by strings.
+  def test_in_modern_ruby_single_characters_are_represented_by_strings
+    assert_equal Exercises::AboutStrings.koans[:character_literal], ?a
+    assert_equal Exercises::AboutStrings.koans[:character_equals_integer], ?a == 97
+  end
+
+  # Checks strings can be split.
+  def test_strings_can_be_split
+    string = "Sausage Egg Cheese"
+    words = string.split
+
+    assert_equal Exercises::AboutStrings.koans[:split_words], words
+  end
+
+  # Checks strings can be split with different patterns.
+  def test_strings_can_be_split_with_different_patterns
+    string = "the:rain:in:spain"
+    words = string.split(/:/)
+
+    assert_equal Exercises::AboutStrings.koans[:pattern_words], words
+
+    # NOTE: Patterns are formed from Regular Expressions.  Ruby has a
+    # powerful Regular Expression library.
+  end
+
+  # Checks strings can be joined.
+  def test_strings_can_be_joined
+    words = %w[Now is the time]
+
+    assert_equal Exercises::AboutStrings.koans[:joined_words], words.join(" ")
+  end
+
+  # Checks strings are unique objects.
+  def test_strings_are_unique_objects
+    a = "a string"
+    b = "a string"
+
+    assert_equal Exercises::AboutStrings.koans[:equal_strings], a == b
+    assert_equal Exercises::AboutStrings.koans[:same_object], a.object_id == b.object_id
+  end
+end
+
+# rubocop:enable Style/StringLiterals, Style/PercentLiteralDelimiters, Style/CharacterLiteral
+# rubocop:enable Style/StringConcatenation, Lint/UselessAssignment, Lint/InterpolationCheck
+# rubocop:enable Minitest/LiteralAsActualArgument, Style/RedundantRegexpArgument, Lint/IdentityComparison

data/test/exercises/about_symbols_test.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+require ARGV.shift
+
+# Observes symbols without interning the names being searched for as expectations.
+class AboutSymbolsTest < Minitest::Test
+  RUBY_CONSTANT = 'What is the sound of one hand clapping?'
+
+  # Symbols have their own type.
+  def test_symbols_are_symbols
+    symbol = :ruby
+
+    assert_equal Exercises::AboutSymbols.koans[:symbol_type], symbol.is_a?(Symbol)
+  end
+
+  # Equal names compare equally; different names do not.
+  def test_symbols_can_be_compared
+    symbol1 = :a_symbol
+    symbol2 = :a_symbol
+    symbol3 = :something_else
+    answers = Exercises::AboutSymbols.koans
+
+    assert_equal answers[:same_value], symbol1 == symbol2
+    assert_equal answers[:different_value], symbol1 == symbol3
+  end
+
+  # Identical symbols share identity as well as value.
+  def test_identical_symbols_are_a_single_internal_object
+    symbol1 = :a_symbol
+    symbol2 = :a_symbol
+    answers = Exercises::AboutSymbols.koans
+
+    assert_equal answers[:identical_value], symbol1 == symbol2
+    assert_equal answers[:same_object], symbol1.equal?(symbol2)
+  end
+
+  # Defined method names occur in the symbol table.
+  def test_method_names_become_symbols
+    names = Symbol.all_symbols.map(&:to_s)
+
+    assert_equal Exercises::AboutSymbols.koans[:method_name_registered],
+                 names.include?('test_method_names_become_symbols')
+  end
+
+  # Constant names are compared as strings to avoid creating a searched-for symbol.
+  def test_constants_become_symbols
+    names = Symbol.all_symbols.map(&:to_s)
+    constant_name = self.class.constants(false).fetch(0).to_s
+    answers = Exercises::AboutSymbols.koans
+
+    assert_equal answers[:constant_name], constant_name
+    assert_equal answers[:constant_registered], names.include?(constant_name)
+  end
+
+  # Strings can be converted into symbols.
+  def test_symbols_can_be_made_from_strings
+    string = 'catsAndDogs'
+
+    assert_equal Exercises::AboutSymbols.koans[:from_string], string.to_sym
+  end
+
+  # Quoting permits spaces inside symbol names.
+  def test_symbols_with_spaces_can_be_built
+    symbol = :'cats and dogs'
+
+    assert_equal Exercises::AboutSymbols.koans[:with_spaces], symbol
+  end
+
+  # Double-quoted symbol syntax supports interpolation.
+  def test_symbols_with_interpolation_can_be_built
+    value = 'and'
+    symbol = :"cats #{value} dogs"
+
+    assert_equal Exercises::AboutSymbols.koans[:with_interpolation], symbol
+  end
+
+  # String interpolation calls a symbol's to_s.
+  def test_to_s_is_called_on_interpolated_symbols
+    symbol = :cats
+    string = "It is raining #{symbol} and dogs."
+
+    assert_equal Exercises::AboutSymbols.koans[:interpolated_text], string
+  end
+
+  # A symbol and a string with the same spelling are different values and types.
+  def test_symbols_are_not_strings
+    symbol = :ruby
+    answers = Exercises::AboutSymbols.koans
+
+    assert_equal answers[:string_type], symbol.is_a?(String)
+    assert_equal answers[:equals_string], symbol.eql?('ruby')
+  end
+
+  # Symbols do not provide these string operations.
+  def test_symbols_do_not_have_string_methods
+    symbol = :not_a_string
+    answers = Exercises::AboutSymbols.koans
+
+    assert_equal answers[:each_char], symbol.respond_to?(:each_char)
+    assert_equal answers[:reverse], symbol.respond_to?(:reverse)
+  end
+
+  # Unsupported concatenation raises an exception whose class can be predicted.
+  def test_symbols_cannot_be_concatenated
+    error = assert_raises(NoMethodError) { :cats + :dogs }
+
+    assert_equal Exercises::AboutSymbols.koans[:concatenation_error], error.class
+  end
+
+  # A constructed string can be converted to a symbol.
+  def test_symbols_can_be_dynamically_created
+    name = 'cats' + 'dogs' # rubocop:disable Style/StringConcatenation
+
+    assert_equal Exercises::AboutSymbols.koans[:dynamically_created], name.to_sym
+  end
+end