rkoans 0.0.1 → 0.1.0

data/test/exercises/about_to_str_test.rb

@@ -0,0 +1,89 @@
+# 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 'tmpdir'
+
+class AboutToStrTest < Minitest::Test
+  class CanNotBeTreatedAsString
+    # Demonstrates to s.
+    def to_s
+      'non-string-like'
+    end
+  end
+
+  # Checks to s returns a string representation.
+  def test_to_s_returns_a_string_representation
+    not_like_a_string = CanNotBeTreatedAsString.new
+
+    assert_equal Exercises::AboutToStr.koans.fetch(:to_s_returns_a_string_representation_one), not_like_a_string.to_s
+  end
+
+  # Checks normally objects cannot be used where strings are expected.
+  def test_normally_objects_cannot_be_used_where_strings_are_expected
+    assert_predicted_error(:normally_objects_cannot_be_used_where_strings_are_expected_one, ::TypeError) do
+      File.exist?(CanNotBeTreatedAsString.new)
+    end
+  end
+
+  # ------------------------------------------------------------------
+
+  class CanBeTreatedAsString
+    # Demonstrates to s.
+    def to_s
+      'string-like'
+    end
+
+    # Demonstrates to str.
+    def to_str
+      to_s
+    end
+  end
+
+  # Checks to str also returns a string representation.
+  def test_to_str_also_returns_a_string_representation
+    like_a_string = CanBeTreatedAsString.new
+
+    assert_equal Exercises::AboutToStr.koans.fetch(:to_str_also_returns_a_string_representation_one),
+                 like_a_string.to_str
+  end
+
+  # Checks to str allows objects to be treated as strings.
+  def test_to_str_allows_objects_to_be_treated_as_strings
+    Dir.mktmpdir do |directory|
+      Dir.chdir(directory) do
+        assert_equal Exercises::AboutToStr.koans.fetch(:to_str_allows_objects_to_be_treated_as_strings_one),
+                     File.exist?(CanBeTreatedAsString.new)
+      end
+    end
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates acts like a string?.
+  def acts_like_a_string?(string)
+    string = string.to_str if string.respond_to?(:to_str)
+    string.is_a?(String)
+  end
+
+  # Checks user defined code can check for to str.
+  def test_user_defined_code_can_check_for_to_str
+    assert_equal Exercises::AboutToStr.koans.fetch(:user_defined_code_can_check_for_to_str_one),
+                 acts_like_a_string?(CanNotBeTreatedAsString.new)
+    assert_equal Exercises::AboutToStr.koans.fetch(:user_defined_code_can_check_for_to_str_two),
+                 acts_like_a_string?(CanBeTreatedAsString.new)
+  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::AboutToStr.koans.fetch(key), error.class
+    error
+  end
+end

data/test/exercises/about_triangle_project_test.rb

@@ -0,0 +1,29 @@
+# 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
+
+class AboutTriangleProjectTest < Minitest::Test
+  # All equal sides make an equilateral triangle, regardless of scale.
+  def test_equilateral_triangles_have_equal_sides
+    assert_equal :equilateral, Exercises::AboutTriangleProject.triangle(2, 2, 2)
+    assert_equal :equilateral, Exercises::AboutTriangleProject.triangle(10, 10, 10)
+  end
+
+  # The equal pair may appear in any positions.
+  def test_isosceles_triangles_have_exactly_two_sides_equal
+    [[3, 4, 4], [4, 3, 4], [4, 4, 3], [10, 10, 2]].each do |sides|
+      assert_equal :isosceles, Exercises::AboutTriangleProject.triangle(*sides)
+    end
+  end
+
+  # Distinct valid sides make a scalene triangle.
+  def test_scalene_triangles_have_no_equal_sides
+    [[3, 4, 5], [10, 11, 12], [5, 4, 2]].each do |sides|
+      assert_equal :scalene, Exercises::AboutTriangleProject.triangle(*sides)
+    end
+  end
+end

data/test/exercises/about_triangle_project_two_test.rb

@@ -0,0 +1,28 @@
+# 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
+
+class AboutTriangleProjectTwoTest < Minitest::Test
+  # Reject nonpositive lengths and both sides of the triangle-inequality boundary.
+  def test_illegal_triangles_throw_exceptions
+    [[0, 0, 0], [3, 4, -5], [1, 1, 3], [2, 4, 2], [0, 1, 1]].each do |sides|
+      sides.permutation.to_a.uniq.each do |ordered|
+        assert_raises(Exercises::AboutTriangleProjectTwo::TriangleError) do
+          Exercises::AboutTriangleProjectTwo.triangle(*ordered)
+        end
+      end
+    end
+  end
+
+  # Validation must preserve the classification behavior from part one.
+  def test_valid_triangles_keep_their_classification
+    assert_equal :equilateral, Exercises::AboutTriangleProjectTwo.triangle(2, 2, 2)
+    assert_equal :isosceles, Exercises::AboutTriangleProjectTwo.triangle(3, 4, 4)
+    assert_equal :scalene, Exercises::AboutTriangleProjectTwo.triangle(3, 4, 5)
+    assert_equal :isosceles, Exercises::AboutTriangleProjectTwo.triangle(1, 1, 1.5)
+  end
+end

data/test/exercises/about_true_and_false_test.rb

@@ -0,0 +1,43 @@
+# 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
+
+# Keeps the original truthiness examples and their independently evaluated branches.
+class AboutTrueAndFalseTest < Minitest::Test
+  # @param condition [Object] value tested by Ruby's ordinary if statement
+  # @return [Symbol] branch selected by Ruby
+  def truth_value(condition)
+    if condition
+      :true_stuff
+    else
+      :false_stuff
+    end
+  end
+
+  # True selects the truthy branch.
+  def test_true_is_treated_as_true
+    assert_equal Exercises::AboutTrueAndFalse.koans[:true_value], truth_value(true)
+  end
+
+  # False selects the falsey branch.
+  def test_false_is_treated_as_false
+    assert_equal Exercises::AboutTrueAndFalse.koans[:false_value], truth_value(false)
+  end
+
+  # Nil selects the same branch as false.
+  def test_nil_is_treated_as_false_too
+    assert_equal Exercises::AboutTrueAndFalse.koans[:nil_value], truth_value(nil)
+  end
+
+  # Zero and empty containers are truthy, just like other ordinary objects.
+  def test_everything_else_is_treated_as_true
+    values = { one: 1, zero: 0, empty_array: [], empty_hash: {}, string: 'Strings', empty_string: '' }
+    answers = Exercises::AboutTrueAndFalse.koans
+
+    values.each { |key, value| assert_equal answers[key], truth_value(value), "Branch for #{key}" }
+  end
+end

data/test/exercises/blocks_and_methods_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+
+# Checks the learner's sequence and the block invocation contract.
+class BlocksAndMethodsTest < Minitest::Test
+  def test_block_koan
+    assert_equal [1, 2, 3], Exercises::BlocksAndMethods.koans[:sequence]
+  end
+
+  def test_apply_block
+    count = 0
+    result = Exercises::BlocksAndMethods.apply(5) do |number|
+      count += 1
+      number * 3
+    end
+
+    assert_equal 15, result
+    assert_equal 1, count
+    assert_raises(LocalJumpError) { Exercises::BlocksAndMethods.apply(5) }
+  end
+end

data/test/exercises/class_state_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# The examples contrast block forms and their behavior.
+# rubocop:disable Style/BlockDelimiters
+
+require ARGV.shift
+class ClassStateTest < Minitest::Test
+  # Checks independent class instance state.
+  def test_independent_class_instance_state
+    Exercises::ClassState::Parent.reset
+    Exercises::ClassState::Child.reset
+    2.times {
+      Exercises::ClassState::Parent.increment
+    }
+
+    Exercises::ClassState::Child.increment
+
+    assert_equal 2, Exercises::ClassState::Parent.count
+    assert_equal 1, Exercises::ClassState::Child.count
+  end
+
+  # Checks class inheritance and singleton.
+  def test_class_inheritance_and_singleton
+    assert_equal 'parent-child', Exercises::ClassState::Child.label
+    assert_equal Exercises::ClassState::Parent.singleton_class, Exercises::ClassState.singleton_owner
+  end
+end
+
+# rubocop:enable Style/BlockDelimiters

data/test/exercises/closure_capture_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# The examples contrast block forms and their behavior.
+# rubocop:disable Style/BlockDelimiters
+
+require ARGV.shift
+class ClosureCaptureTest < Minitest::Test
+  # Checks separate captures.
+  def test_separate_captures
+    functions = Exercises::ClosureCapture.multipliers([2, 3, 4])
+
+    assert_equal([10, 15, 20], functions.map { |f|
+      f.call(5)
+    })
+  end
+
+  # Checks lambda contract.
+  def test_lambda_contract
+    f = Exercises::ClosureCapture.multipliers([2]).first
+
+    assert_predicate f, :lambda?
+    assert_raises(ArgumentError) {
+      f.call(5, 6)
+    }
+    assert_equal [], Exercises::ClosureCapture.multipliers([])
+  end
+end
+
+# rubocop:enable Style/BlockDelimiters

data/test/exercises/collection_basics_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+
+# Checks the learner's expectations and the double_odds contract.
+class CollectionBasicsTest < Minitest::Test
+  def test_collection_koans
+    assert_equal({ mapped: [2, 4, 6], selected: [1, 3] }, Exercises::CollectionBasics.koans)
+  end
+
+  def test_double_odds
+    input = [1, 2, 3]
+
+    assert_equal [2, 6], Exercises::CollectionBasics.double_odds(input)
+    assert_equal [1, 2, 3], input
+    assert_empty Exercises::CollectionBasics.double_odds([])
+  end
+end

data/test/exercises/constant_scope_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class ConstantScopeTest < Minitest::Test
+  # Checks scope predictions.
+  def test_scope_predictions
+    assert_equal({ lexical_label: 'item', shared_class_count: 1, new_block_local_visible: false }, Exercises::ConstantScope.predictions)
+  end
+
+  # Checks local closure state.
+  def test_local_closure_state
+    a = Exercises::ConstantScope.counter
+
+    b = Exercises::ConstantScope.counter
+
+    assert_equal [1, 2, 1], [a.call, a.call, b.call]
+  end
+end

data/test/exercises/core_protocols_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# The examples contrast block forms and their behavior.
+# rubocop:disable Style/BlockDelimiters
+
+require ARGV.shift
+class CoreProtocolsTest < Minitest::Test
+  # Checks enumerable protocol.
+  def test_enumerable_protocol
+    p = Exercises::CoreProtocols::Packet.new([2, 3]); assert_equal([4, 6], p.map { |n|
+      n * 2
+    })
+    assert_equal [2, 3], p.each.to_a
+    assert_equal [true, true], Exercises::CoreProtocols.protocol(p)
+  end
+
+  # Checks comparable and conversion.
+  def test_comparable_and_conversion
+    a = Exercises::CoreProtocols::Packet.new([1])
+    b = Exercises::CoreProtocols::Packet.new([2, 3])
+
+    assert_operator a, :<, b
+    assert_equal 'Packet(5)', b.to_s
+    assert_equal [a, b], [b, a].sort
+  end
+end
+
+# rubocop:enable Style/BlockDelimiters

data/test/exercises/delegation_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class DelegationTest < Minitest::Test
+  # Checks delegation receiver.
+  def test_delegation_receiver
+    items = []
+    box = Exercises::Delegation::Mailbox.new(items)
+
+    assert_same items, box.push('ruby')
+    assert_equal ['ruby'], items
+    assert_equal 1, box.size
+  end
+
+  # Checks live receiver.
+  def test_live_receiver
+    items = []
+    box = Exercises::Delegation::Mailbox.new(items)
+    items << 'rails'
+
+    assert_equal 1, box.size
+  end
+end

data/test/exercises/dynamic_methods_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class DynamicMethodsTest < Minitest::Test
+  # Checks defined reader closures.
+  def test_defined_reader_closures
+    klass = Exercises::DynamicMethods.readers(%i[left right])
+    obj = klass.new
+
+    obj.instance_variable_set(:@left, 10)
+    obj.instance_variable_set(:@right, 20)
+
+    assert_equal [10, 20], [obj.left, obj.right]
+  end
+
+  # Checks eval binding and reflection.
+  def test_eval_binding_and_reflection
+    assert_equal 8, Exercises::DynamicMethods.evaluate(4)
+    obj = Object.new
+
+    obj.instance_variable_set(:@token, :ruby)
+
+    assert_equal :ruby, Exercises::DynamicMethods.instance_value(obj, :token)
+    klass = Exercises::DynamicMethods.readers([])
+
+    assert_equal klass, Exercises::DynamicMethods.class_value(klass)
+  end
+end

data/test/exercises/exception_flow_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class ExceptionFlowTest < Minitest::Test
+  # Checks ensure and else.
+  def test_ensure_and_else
+    assert_equal %w[work else ensure], Exercises::ExceptionFlow.trace(fail: false)
+
+    assert_equal %w[work rescue ensure], Exercises::ExceptionFlow.trace(fail: true)
+  end
+
+  # Checks reraise.
+  def test_reraise
+    error = assert_raises(ArgumentError) { Exercises::ExceptionFlow.reraises }
+    assert_equal 'original', error.message
+  end
+end

data/test/exercises/heredoc_layout_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+
+# Checks exact output bytes without deriving expectations from the learner's code.
+class HeredocLayoutTest < Minitest::Test
+  # Common indentation is stripped; relative spaces and newlines remain intact.
+  def test_squiggly_indentation
+    assert_equal "Hello Ada\n  Ruby\n", Exercises::HeredocLayout.render('Ada')
+    assert_equal "Hello Bea\n  Ruby\n", Exercises::HeredocLayout.render('Bea')
+    assert_equal "Hello \n  Ruby\n", Exercises::HeredocLayout.render('')
+  end
+
+  # Quoting the delimiter prevents interpolation without dropping the final newline.
+  def test_quoted_heredoc
+    assert_equal "Hello \#{name}\n", Exercises::HeredocLayout.literal
+  end
+end

data/test/exercises/keyword_forwarding_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Explicit callable arguments demonstrate block and proc behavior.
+# rubocop:disable Style/SymbolProc
+
+require ARGV.shift
+class KeywordForwardingTest < Minitest::Test
+  # Checks keyword and block.
+  def test_keyword_and_block
+    assert_equal 'RUBY!', Exercises::KeywordForwarding.forward('ruby', suffix: '!') { |v|
+      v.upcase
+    }
+    assert_equal 'ruby?', Exercises::KeywordForwarding.forward('ruby')
+  end
+
+  # Checks positional hash.
+  def test_positional_hash
+    assert_equal 'rails!', Exercises::KeywordForwarding.forward({ name: 'rails' }, suffix: '!') { |payload| payload.fetch(:name) }
+  end
+end
+
+# rubocop:enable Style/SymbolProc

data/test/exercises/lazy_enumeration_test.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class LazyEnumerationTest < Minitest::Test
+  # Checks lazy limit.
+  def test_lazy_limit
+    assert_equal [7, 14], Exercises::LazyEnumeration.first_multiples(2)
+    assert_equal [7, 14, 21, 28], Exercises::LazyEnumeration.first_multiples(4)
+  end
+
+  # Checks empty limit.
+  def test_empty_limit
+    assert_equal [], Exercises::LazyEnumeration.first_multiples(0)
+  end
+end

data/test/exercises/literals_and_operators_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class LiteralsAndOperatorsTest < Minitest::Test
+  # Checks literals and precedence.
+  def test_literals_and_precedence
+    assert_equal({
+                   zero_truthy: true,
+                   integer_division: 2,
+                   float_division: 2.5,
+                   precedence: 7,
+                   not_nil: true,
+                   words: %w[ruby rails],
+                   range: [1, 2, 3]
+                 }, Exercises::LiteralsAndOperators.predictions)
+  end
+
+  # Checks short circuit default.
+  def test_short_circuit_default
+    assert_equal false, Exercises::LiteralsAndOperators.default_for_nil(false) # rubocop:disable Minitest/RefuteFalse
+
+    assert_equal 0, Exercises::LiteralsAndOperators.default_for_nil(0)
+    assert_equal 'missing', Exercises::LiteralsAndOperators.default_for_nil(nil)
+  end
+end

data/test/exercises/method_contracts_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# The original descriptive check identifiers and example strings remain intact.
+# The examples contrast block forms and their behavior.
+# Explicit callable arguments demonstrate block and proc behavior.
+# rubocop:disable Layout/LineLength, Style/BlockDelimiters, Style/SymbolProc
+
+require ARGV.shift
+class MethodContractsTest < Minitest::Test
+  # Checks method defaults and block.
+  def test_method_defaults_and_block
+    assert_equal 'tea:1:box:0:normal', Exercises::MethodContracts.format_order('tea', unit: 'box')
+    assert_equal 'TEA:2:BOX:1:HIGH', Exercises::MethodContracts.format_order('tea', 2, :gift, unit: 'box', priority: 'high') { |v|
+      v.upcase
+    }
+  end
+
+  # Checks parameter metadata.
+  def test_parameter_metadata
+    assert_equal [%i[req name], %i[opt quantity], %i[rest extras], %i[keyreq unit], %i[keyrest options], %i[block block]],
+                 Exercises::MethodContracts.parameters
+    assert_raises(ArgumentError) {
+      Exercises::MethodContracts.format_order('tea')
+    }
+  end
+end
+
+# rubocop:enable Layout/LineLength, Style/BlockDelimiters, Style/SymbolProc

data/test/exercises/method_lookup_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class MethodLookupTest < Minitest::Test
+  # Checks prepend wrapper.
+  def test_prepend_wrapper
+    assert_equal '[base]', Exercises::MethodLookup::Presenter.new.call
+  end
+
+  # Checks ancestor order.
+  def test_ancestor_order
+    assert_equal ['Exercises::MethodLookup::Wrapper', 'Exercises::MethodLookup::Presenter'], Exercises::MethodLookup.lookup
+  end
+end

data/test/exercises/nonlocal_exit_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class NonlocalExitTest < Minitest::Test
+  # Checks lambda return scope.
+  def test_lambda_return_scope
+    assert_equal %w[inside after], Exercises::NonlocalExit.lambda_trace
+  end
+
+  # Checks proc nonlocal return.
+  def test_proc_nonlocal_return
+    assert_raises(LocalJumpError) { Exercises::NonlocalExit.escaped_proc.call }
+  end
+
+  # Checks catch throw and next.
+  def test_catch_throw_and_next
+    assert_equal 4, Exercises::NonlocalExit.find_even([[1, 3], [4, 6]])
+    assert_nil Exercises::NonlocalExit.find_even([[1], [3]])
+
+    assert_equal [2, 4], Exercises::NonlocalExit.skip_odds([1, 2, 3, 4])
+  end
+end

data/test/exercises/numbered_parameters_test.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class NumberedParametersTest < Minitest::Test
+  # Checks numbered pair input.
+  def test_numbered_pair_input
+    assert_equal [5, 9], Exercises::NumberedParameters.pair_sums([[2, 3], [4, 5]])
+    assert_equal [], Exercises::NumberedParameters.pair_sums([])
+  end
+
+  # Checks numbered syntax.
+  def test_numbered_syntax
+    assert_equal({ explicit_and_numbered: false, numbered_pair: true }, Exercises::NumberedParameters.predictions)
+  end
+end

data/test/exercises/numeric_precision_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class NumericPrecisionTest < Minitest::Test
+  # Checks numeric division.
+  def test_numeric_division
+    result = Exercises::NumericPrecision.ratios(1, 3)
+
+    assert_instance_of Integer, result[:integer]
+    assert_equal 0, result[:integer]
+    assert_instance_of Float, result[:floating]
+    assert_in_delta 1.0 / 3, result[:floating], 1e-12
+    assert_instance_of Rational, result[:rational]
+    assert_equal Rational(4, 3), result[:rational] + 1
+  end
+
+  # Checks complex product.
+  def test_complex_product
+    product = Exercises::NumericPrecision.imaginary_product(2, 3)
+
+    assert_instance_of Complex, product
+    assert_equal Complex(-6, 0), product
+  end
+end

data/test/exercises/pattern_matching_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class PatternMatchingTest < Minitest::Test
+  # Checks pinned kind.
+  def test_pinned_kind
+    assert_equal 5, Exercises::PatternMatching.amount({ type: 'sale', amount: 5, extra: true }, 'sale')
+    assert_nil Exercises::PatternMatching.amount({ type: 'refund', amount: 5 }, 'sale')
+  end
+
+  # Checks pattern guard.
+  def test_pattern_guard
+    assert_nil Exercises::PatternMatching.amount({ type: 'sale', amount: 0 }, 'sale')
+
+    assert_nil Exercises::PatternMatching.amount({ type: 'sale', amount: '5' }, 'sale')
+    assert_nil Exercises::PatternMatching.amount({}, 'sale')
+  end
+end

data/test/exercises/refinement_scope_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class RefinementScopeTest < Minitest::Test
+  # Checks lexical refinement.
+  def test_lexical_refinement
+    assert_equal 'local', Exercises::RefinementScope::Local.call
+  end
+
+  # Checks outside unchanged.
+  def test_outside_unchanged
+    assert_equal 'plain', Exercises::RefinementScope.outside
+  end
+end

data/test/exercises/regexp_captures_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require ARGV.shift
+class RegexpCapturesTest < Minitest::Test
+  # Checks whole string and captures.
+  def test_whole_string_and_captures
+    parsed = Exercises::RegexpCaptures.parse('ruby:42')
+
+    assert_equal({ name: 'ruby', id: 42 }, parsed)
+    assert_instance_of Integer, parsed.fetch(:id)
+    assert_nil Exercises::RegexpCaptures.parse("ruby:42\n")
+    assert_nil Exercises::RegexpCaptures.parse('ruby:x')
+  end
+
+  # Checks match without global capture change.
+  def test_match_without_global_capture_change
+    assert_equal ['old', true], Exercises::RegexpCaptures.probe('ruby')
+    assert_equal ['old', false], Exercises::RegexpCaptures.probe('rails')
+  end
+end