diff --git a/exercises/practice/largest-series-product/.meta/test_template.erb b/exercises/practice/largest-series-product/.meta/test_template.erb
new file mode 100644
index 0000000000..509c20154b
--- /dev/null
+++ b/exercises/practice/largest-series-product/.meta/test_template.erb
@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+require_relative 'largest_series_product'
+
+class LargestSeriesProductTest < Minitest::Test
+<% json["cases"].each do |cases| %>
+    def test_<%= underscore(cases["description"]) %>
+        <%= skip? %>
+        <%- if cases["expected"].is_a?(Hash) && cases["expected"].key?("error") -%>
+            assert_raises(ArgumentError) do
+                Series.new('<%= cases["input"]["digits"] %>').largest_product(<%= cases["input"]["span"] %>)
+            end
+        <%- else -%>
+            assert_equal <%= cases["expected"] %>, Series.new('<%= cases["input"]["digits"] %>').largest_product(<%= cases["input"]["span"] %>)
+        <%- end -%>
+    end
+    <% end %>
+end
diff --git a/exercises/practice/largest-series-product/.meta/tests.toml b/exercises/practice/largest-series-product/.meta/tests.toml
index 8831692597..982f517cc3 100644
--- a/exercises/practice/largest-series-product/.meta/tests.toml
+++ b/exercises/practice/largest-series-product/.meta/tests.toml
@@ -38,6 +38,11 @@ description = "reports zero if all spans include zero"
 
 [5d81aaf7-4f67-4125-bf33-11493cc7eab7]
 description = "rejects span longer than string length"
+include = false
+
+[0ae1ce53-d9ba-41bb-827f-2fceb64f058b]
+description = "rejects span longer than string length"
+reimplements = "5d81aaf7-4f67-4125-bf33-11493cc7eab7"
 
 [06bc8b90-0c51-4c54-ac22-3ec3893a079e]
 description = "reports 1 for empty string and empty product (0 span)"
@@ -49,6 +54,11 @@ include = false
 
 [6d96c691-4374-4404-80ee-2ea8f3613dd4]
 description = "rejects empty string and nonzero span"
+include = false
+
+[6cf66098-a6af-4223-aab1-26aeeefc7402]
+description = "rejects empty string and nonzero span"
+reimplements = "6d96c691-4374-4404-80ee-2ea8f3613dd4"
 
 [7a38f2d6-3c35-45f6-8d6f-12e6e32d4d74]
 description = "rejects invalid character in digits"
diff --git a/exercises/practice/largest-series-product/largest_series_product_test.rb b/exercises/practice/largest-series-product/largest_series_product_test.rb
index 6a074fed4c..ab9a9cb03f 100644
--- a/exercises/practice/largest-series-product/largest_series_product_test.rb
+++ b/exercises/practice/largest-series-product/largest_series_product_test.rb
@@ -4,74 +4,74 @@
 class LargestSeriesProductTest < Minitest::Test
   def test_finds_the_largest_product_if_span_equals_length
     # skip
-    assert_equal 18, Series.new("29").largest_product(2)
+    assert_equal 18, Series.new('29').largest_product(2)
   end
 
   def test_can_find_the_largest_product_of_2_with_numbers_in_order
     skip
-    assert_equal 72, Series.new("0123456789").largest_product(2)
+    assert_equal 72, Series.new('0123456789').largest_product(2)
   end
 
   def test_can_find_the_largest_product_of_2
     skip
-    assert_equal 48, Series.new("576802143").largest_product(2)
+    assert_equal 48, Series.new('576802143').largest_product(2)
   end
 
   def test_can_find_the_largest_product_of_3_with_numbers_in_order
     skip
-    assert_equal 504, Series.new("0123456789").largest_product(3)
+    assert_equal 504, Series.new('0123456789').largest_product(3)
   end
 
   def test_can_find_the_largest_product_of_3
     skip
-    assert_equal 270, Series.new("1027839564").largest_product(3)
+    assert_equal 270, Series.new('1027839564').largest_product(3)
   end
 
   def test_can_find_the_largest_product_of_5_with_numbers_in_order
     skip
-    assert_equal 15_120, Series.new("0123456789").largest_product(5)
+    assert_equal 15_120, Series.new('0123456789').largest_product(5)
   end
 
   def test_can_get_the_largest_product_of_a_big_number
     skip
-    assert_equal 23_520, Series.new("73167176531330624919225119674426574742355349194934").largest_product(6)
+    assert_equal 23_520, Series.new('73167176531330624919225119674426574742355349194934').largest_product(6)
   end
 
   def test_reports_zero_if_the_only_digits_are_zero
     skip
-    assert_equal 0, Series.new("0000").largest_product(2)
+    assert_equal 0, Series.new('0000').largest_product(2)
   end
 
   def test_reports_zero_if_all_spans_include_zero
     skip
-    assert_equal 0, Series.new("99099").largest_product(3)
+    assert_equal 0, Series.new('99099').largest_product(3)
   end
 
   def test_rejects_span_longer_than_string_length
     skip
     assert_raises(ArgumentError) do
-      Series.new("123").largest_product(4)
+      Series.new('123').largest_product(4)
     end
   end
 
   def test_rejects_empty_string_and_nonzero_span
     skip
     assert_raises(ArgumentError) do
-      Series.new("").largest_product(1)
+      Series.new('').largest_product(1)
     end
   end
 
   def test_rejects_invalid_character_in_digits
     skip
     assert_raises(ArgumentError) do
-      Series.new("1234a5").largest_product(2)
+      Series.new('1234a5').largest_product(2)
     end
   end
 
   def test_rejects_negative_span
     skip
     assert_raises(ArgumentError) do
-      Series.new("12345").largest_product(-1)
+      Series.new('12345').largest_product(-1)
     end
   end
 end
diff --git a/exercises/practice/leap/.meta/test_template.erb b/exercises/practice/leap/.meta/test_template.erb
new file mode 100644
index 0000000000..07520e2894
--- /dev/null
+++ b/exercises/practice/leap/.meta/test_template.erb
@@ -0,0 +1,20 @@
+require 'minitest/autorun'
+require_relative 'leap'
+
+class Date
+  def leap?
+    raise "Write this functionality yourself instead of using Ruby's `leap?` method."
+  end
+
+  alias gregorian_leap? leap?
+  alias julian_leap? leap?
+end
+
+class YearTest < Minitest::Test
+<% json["cases"].each do |cases| %>
+    def test_<%= underscore(cases["description"]) %>
+        <%= skip? %>
+        <%= cases["expected"] ? "assert" : "refute" %> Year.leap?(<%= cases["input"]["year"] %>), "Expected '<%= cases["expected"] %>', <%= cases["input"]["year"] %> is<%= cases["expected"] ? "" : " not" %> a leap year"
+    end
+    <% end %>
+end
diff --git a/exercises/practice/leap/leap_test.rb b/exercises/practice/leap/leap_test.rb
index 9f5bd6cbcd..1b7b623db8 100644
--- a/exercises/practice/leap/leap_test.rb
+++ b/exercises/practice/leap/leap_test.rb
@@ -3,7 +3,7 @@
 
 class Date
   def leap?
-    raise "Implement this yourself instead of using Ruby's implementation."
+    raise "Write this functionality yourself instead of using Ruby's `leap?` method."
   end
 
   alias gregorian_leap? leap?
@@ -11,28 +11,48 @@ def leap?
 end
 
 class YearTest < Minitest::Test
-  def test_year_not_divisible_by_4_common_year
+  def test_year_not_divisible_by_4_in_common_year
     # skip
-    refute Year.leap?(2015), "Expected 'false', 2015 is not a leap year."
+    refute Year.leap?(2015), "Expected 'false', 2015 is not a leap year"
   end
 
-  def test_year_divisible_by_4_not_divisible_by_100_leap_year
+  def test_year_divisible_by_2_not_divisible_by_4_in_common_year
     skip
-    assert Year.leap?(1996), "Expected 'true', 1996 is a leap year."
+    refute Year.leap?(1970), "Expected 'false', 1970 is not a leap year"
   end
 
-  def test_year_divisible_by_100_not_divisible_by_400_common_year
+  def test_year_divisible_by_4_not_divisible_by_100_in_leap_year
     skip
-    refute Year.leap?(2100), "Expected 'false', 2100 is not a leap year."
+    assert Year.leap?(1996), "Expected 'true', 1996 is a leap year"
   end
 
-  def test_year_divisible_by_400_leap_year
+  def test_year_divisible_by_4_and_5_is_still_a_leap_year
     skip
-    assert Year.leap?(2000), "Expected 'true', 2000 is a leap year."
+    assert Year.leap?(1960), "Expected 'true', 1960 is a leap year"
   end
 
-  def test_year_divisible_by_200_not_divisible_by_400_common_year
+  def test_year_divisible_by_100_not_divisible_by_400_in_common_year
     skip
-    refute Year.leap?(1800), "Expected 'false', 1800 is not a leap year."
+    refute Year.leap?(2100), "Expected 'false', 2100 is not a leap year"
+  end
+
+  def test_year_divisible_by_100_but_not_by_3_is_still_not_a_leap_year
+    skip
+    refute Year.leap?(1900), "Expected 'false', 1900 is not a leap year"
+  end
+
+  def test_year_divisible_by_400_is_leap_year
+    skip
+    assert Year.leap?(2000), "Expected 'true', 2000 is a leap year"
+  end
+
+  def test_year_divisible_by_400_but_not_by_125_is_still_a_leap_year
+    skip
+    assert Year.leap?(2400), "Expected 'true', 2400 is a leap year"
+  end
+
+  def test_year_divisible_by_200_not_divisible_by_400_in_common_year
+    skip
+    refute Year.leap?(1800), "Expected 'false', 1800 is not a leap year"
   end
 end
diff --git a/exercises/practice/linked-list/.meta/example.rb b/exercises/practice/linked-list/.meta/example.rb
index 9486ae370e..7e6a5fc147 100644
--- a/exercises/practice/linked-list/.meta/example.rb
+++ b/exercises/practice/linked-list/.meta/example.rb
@@ -1,6 +1,5 @@
 class Element
-  attr_accessor :prev
-  attr_accessor :next
+  attr_accessor :prev, :next
   attr_reader :datum
 
   def initialize(datum, next_element = nil, prev = nil)
@@ -49,4 +48,37 @@ def shift
     end
     value
   end
+
+  def delete(value)
+    return if @front.nil?
+
+    current = @front
+    loop do
+      if current.datum == value
+        if current.equal?(@front) && current.next.equal?(@front)
+          @front = nil
+        else
+          current.prev.next = current.next
+          current.next.prev = current.prev
+          @front = current.next if current.equal?(@front)
+        end
+        break
+      end
+      current = current.next
+      break if current.equal?(@front)
+    end
+  end
+
+  def count
+    return 0 if @front.nil?
+
+    count = 0
+    current = @front
+    loop do
+      count += 1
+      current = current.next
+      break if current.equal?(@front)
+    end
+    count
+  end
 end
diff --git a/exercises/practice/linked-list/.meta/test_template.erb b/exercises/practice/linked-list/.meta/test_template.erb
new file mode 100644
index 0000000000..dafdca9456
--- /dev/null
+++ b/exercises/practice/linked-list/.meta/test_template.erb
@@ -0,0 +1,18 @@
+require 'minitest/autorun'
+require_relative 'linked_list'
+
+class DequeTest < Minitest::Test
+<% json["cases"].each do |cases| %>
+    def test_<%= underscore(cases["description"]) %>
+        #<%= skip? %>
+        deque = Deque.new
+        <%- cases["input"]["operations"].each do |operation| -%>
+            <%- if operation["expected"] -%>
+                assert_equal <%= operation["expected"] %>, deque.<%= operation["operation"] %>(<%= operation["value"] %>)
+            <%- else -%>
+                deque.<%= operation["operation"] %>(<%= operation["value"] %>)
+            <%- end -%>
+        <%- end -%>
+    end
+    <% end %>
+end
diff --git a/exercises/practice/linked-list/linked_list_test.rb b/exercises/practice/linked-list/linked_list_test.rb
index 9e541e2979..804e2659f1 100644
--- a/exercises/practice/linked-list/linked_list_test.rb
+++ b/exercises/practice/linked-list/linked_list_test.rb
@@ -2,71 +2,196 @@
 require_relative 'linked_list'
 
 class DequeTest < Minitest::Test
-  def test_push_pop
+  def test_pop_gets_element_from_the_list
+    ## skip
     deque = Deque.new
-    deque.push(10)
-    deque.push(20)
-    assert_equal 20, deque.pop
-    assert_equal 10, deque.pop
+    deque.push(7)
+    assert_equal 7, deque.pop
   end
 
-  def test_push_shift
-    skip
+  def test_pushpop_respectively_addremove_at_the_end_of_the_list
+    # skip
     deque = Deque.new
-    deque.push(10)
-    deque.push(20)
-    assert_equal 10, deque.shift
-    assert_equal 20, deque.shift
+    deque.push(11)
+    deque.push(13)
+    assert_equal 13, deque.pop
+    assert_equal 11, deque.pop
   end
 
-  def test_unshift_shift
-    skip
+  def test_shift_gets_an_element_from_the_list
+    # skip
     deque = Deque.new
-    deque.unshift(10)
-    deque.unshift(20)
-    assert_equal 20, deque.shift
-    assert_equal 10, deque.shift
+    deque.push(17)
+    assert_equal 17, deque.shift
   end
 
-  def test_unshift_pop
-    skip
+  def test_shift_gets_first_element_from_the_list
+    # skip
     deque = Deque.new
-    deque.unshift(10)
-    deque.unshift(20)
-    assert_equal 10, deque.pop
-    assert_equal 20, deque.pop
+    deque.push(23)
+    deque.push(5)
+    assert_equal 23, deque.shift
+    assert_equal 5, deque.shift
   end
 
-  def test_example
-    skip
+  def test_unshift_adds_element_at_start_of_the_list
+    # skip
     deque = Deque.new
-    deque.push(10)
-    deque.push(20)
-    assert_equal 20, deque.pop
-    deque.push(30)
-    assert_equal 10, deque.shift
-    deque.unshift(40)
-    deque.push(50)
-    assert_equal 40, deque.shift
-    assert_equal 50, deque.pop
-    assert_equal 30, deque.shift
+    deque.unshift(23)
+    deque.unshift(5)
+    assert_equal 5, deque.shift
+    assert_equal 23, deque.shift
   end
 
-  def test_pop_to_empty
-    skip
+  def test_pop_push_shift_and_unshift_can_be_used_in_any_order
+    # skip
     deque = Deque.new
-    deque.push(10)
-    assert_equal 10, deque.pop
-    deque.push(20)
-    assert_equal 20, deque.shift
+    deque.push(1)
+    deque.push(2)
+    assert_equal 2, deque.pop
+    deque.push(3)
+    assert_equal 1, deque.shift
+    deque.unshift(4)
+    deque.push(5)
+    assert_equal 4, deque.shift
+    assert_equal 5, deque.pop
+    assert_equal 3, deque.shift
   end
 
-  def test_shift_to_empty
-    skip
+  def test_count_an_empty_list
+    # skip
     deque = Deque.new
-    deque.unshift(10)
-    assert_equal 10, deque.shift
-    deque.unshift(20)
-    assert_equal 20, deque.pop
+    assert_equal 0, deque.count
+  end
+
+  def test_count_a_list_with_items
+    # skip
+    deque = Deque.new
+    deque.push(37)
+    deque.push(1)
+    assert_equal 2, deque.count
+  end
+
+  def test_count_is_correct_after_mutation
+    # skip
+    deque = Deque.new
+    deque.push(31)
+    assert_equal 1, deque.count
+    deque.unshift(43)
+    assert_equal 2, deque.count
+    deque.shift
+    assert_equal 1, deque.count
+    deque.pop
+    assert_equal 0, deque.count
+  end
+
+  def test_popping_to_empty_doesnt_break_the_list
+    # skip
+    deque = Deque.new
+    deque.push(41)
+    deque.push(59)
+    deque.pop
+    deque.pop
+    deque.push(47)
+    assert_equal 1, deque.count
+    assert_equal 47, deque.pop
+  end
+
+  def test_shifting_to_empty_doesnt_break_the_list
+    # skip
+    deque = Deque.new
+    deque.push(41)
+    deque.push(59)
+    deque.shift
+    deque.shift
+    deque.push(47)
+    assert_equal 1, deque.count
+    assert_equal 47, deque.shift
+  end
+
+  def test_deletes_the_only_element
+    # skip
+    deque = Deque.new
+    deque.push(61)
+    deque.delete(61)
+    assert_equal 0, deque.count
+  end
+
+  def test_deletes_the_element_with_the_specified_value_from_the_list
+    # skip
+    deque = Deque.new
+    deque.push(71)
+    deque.push(83)
+    deque.push(79)
+    deque.delete(83)
+    assert_equal 2, deque.count
+    assert_equal 79, deque.pop
+    assert_equal 71, deque.shift
+  end
+
+  def test_deletes_the_element_with_the_specified_value_from_the_list_re_assigns_tail
+    # skip
+    deque = Deque.new
+    deque.push(71)
+    deque.push(83)
+    deque.push(79)
+    deque.delete(83)
+    assert_equal 2, deque.count
+    assert_equal 79, deque.pop
+    assert_equal 71, deque.pop
+  end
+
+  def test_deletes_the_element_with_the_specified_value_from_the_list_re_assigns_head
+    # skip
+    deque = Deque.new
+    deque.push(71)
+    deque.push(83)
+    deque.push(79)
+    deque.delete(83)
+    assert_equal 2, deque.count
+    assert_equal 71, deque.shift
+    assert_equal 79, deque.shift
+  end
+
+  def test_deletes_the_first_of_two_elements
+    # skip
+    deque = Deque.new
+    deque.push(97)
+    deque.push(101)
+    deque.delete(97)
+    assert_equal 1, deque.count
+    assert_equal 101, deque.pop
+  end
+
+  def test_deletes_the_second_of_two_elements
+    # skip
+    deque = Deque.new
+    deque.push(97)
+    deque.push(101)
+    deque.delete(101)
+    assert_equal 1, deque.count
+    assert_equal 97, deque.pop
+  end
+
+  def test_delete_does_not_modify_the_list_if_the_element_is_not_found
+    # skip
+    deque = Deque.new
+    deque.push(89)
+    deque.delete(103)
+    assert_equal 1, deque.count
+  end
+
+  def test_deletes_only_the_first_occurrence
+    # skip
+    deque = Deque.new
+    deque.push(73)
+    deque.push(9)
+    deque.push(9)
+    deque.push(107)
+    deque.delete(9)
+    assert_equal 3, deque.count
+    assert_equal 107, deque.pop
+    assert_equal 9, deque.pop
+    assert_equal 73, deque.pop
   end
 end
diff --git a/exercises/practice/luhn/.meta/test_template.erb b/exercises/practice/luhn/.meta/test_template.erb
new file mode 100644
index 0000000000..c5ecf290a4
--- /dev/null
+++ b/exercises/practice/luhn/.meta/test_template.erb
@@ -0,0 +1,11 @@
+require 'minitest/autorun'
+require_relative 'luhn'
+
+class LuhnTest < Minitest::Test
+<% json["cases"].each do |cases| %>
+    def test_<%= underscore(cases["description"]) %>
+        <%= skip? %>
+        <%= cases["expected"] ? "assert" : "refute" %> Luhn.valid?('<%= cases["input"]["value"] %>')
+    end
+    <% end %>
+end
diff --git a/exercises/practice/luhn/luhn_test.rb b/exercises/practice/luhn/luhn_test.rb
index 57dcb74388..6e81b33068 100644
--- a/exercises/practice/luhn/luhn_test.rb
+++ b/exercises/practice/luhn/luhn_test.rb
@@ -4,111 +4,111 @@
 class LuhnTest < Minitest::Test
   def test_single_digit_strings_can_not_be_valid
     # skip
-    refute Luhn.valid?("1")
+    refute Luhn.valid?('1')
   end
 
   def test_a_single_zero_is_invalid
     skip
-    refute Luhn.valid?("0")
+    refute Luhn.valid?('0')
   end
 
   def test_a_simple_valid_sin_that_remains_valid_if_reversed
     skip
-    assert Luhn.valid?("059")
+    assert Luhn.valid?('059')
   end
 
   def test_a_simple_valid_sin_that_becomes_invalid_if_reversed
     skip
-    assert Luhn.valid?("59")
+    assert Luhn.valid?('59')
   end
 
   def test_a_valid_canadian_sin
     skip
-    assert Luhn.valid?("055 444 285")
+    assert Luhn.valid?('055 444 285')
   end
 
   def test_invalid_canadian_sin
     skip
-    refute Luhn.valid?("055 444 286")
+    refute Luhn.valid?('055 444 286')
   end
 
   def test_invalid_credit_card
     skip
-    refute Luhn.valid?("8273 1232 7352 0569")
+    refute Luhn.valid?('8273 1232 7352 0569')
   end
 
   def test_invalid_long_number_with_an_even_remainder
     skip
-    refute Luhn.valid?("1 2345 6789 1234 5678 9012")
+    refute Luhn.valid?('1 2345 6789 1234 5678 9012')
   end
 
   def test_invalid_long_number_with_a_remainder_divisible_by_5
     skip
-    refute Luhn.valid?("1 2345 6789 1234 5678 9013")
+    refute Luhn.valid?('1 2345 6789 1234 5678 9013')
   end
 
   def test_valid_number_with_an_even_number_of_digits
     skip
-    assert Luhn.valid?("095 245 88")
+    assert Luhn.valid?('095 245 88')
   end
 
   def test_valid_number_with_an_odd_number_of_spaces
     skip
-    assert Luhn.valid?("234 567 891 234")
+    assert Luhn.valid?('234 567 891 234')
   end
 
   def test_valid_strings_with_a_non_digit_added_at_the_end_become_invalid
     skip
-    refute Luhn.valid?("059a")
+    refute Luhn.valid?('059a')
   end
 
   def test_valid_strings_with_punctuation_included_become_invalid
     skip
-    refute Luhn.valid?("055-444-285")
+    refute Luhn.valid?('055-444-285')
   end
 
   def test_valid_strings_with_symbols_included_become_invalid
     skip
-    refute Luhn.valid?("055# 444$ 285")
+    refute Luhn.valid?('055# 444$ 285')
   end
 
   def test_single_zero_with_space_is_invalid
     skip
-    refute Luhn.valid?(" 0")
+    refute Luhn.valid?(' 0')
   end
 
   def test_more_than_a_single_zero_is_valid
     skip
-    assert Luhn.valid?("0000 0")
+    assert Luhn.valid?('0000 0')
   end
 
   def test_input_digit_9_is_correctly_converted_to_output_digit_9
     skip
-    assert Luhn.valid?("091")
+    assert Luhn.valid?('091')
   end
 
   def test_very_long_input_is_valid
     skip
-    assert Luhn.valid?("9999999999 9999999999 9999999999 9999999999")
+    assert Luhn.valid?('9999999999 9999999999 9999999999 9999999999')
   end
 
   def test_valid_luhn_with_an_odd_number_of_digits_and_non_zero_first_digit
     skip
-    assert Luhn.valid?("109")
+    assert Luhn.valid?('109')
   end
 
   def test_using_ascii_value_for_non_doubled_non_digit_isnt_allowed
     skip
-    refute Luhn.valid?("055b 444 285")
+    refute Luhn.valid?('055b 444 285')
   end
 
   def test_using_ascii_value_for_doubled_non_digit_isnt_allowed
     skip
-    refute Luhn.valid?(":9")
+    refute Luhn.valid?(':9')
   end
 
   def test_non_numeric_non_space_char_in_the_middle_with_a_sum_thats_divisible_by_10_isnt_allowed
     skip
-    refute Luhn.valid?("59%59")
+    refute Luhn.valid?('59%59')
   end
 end
diff --git a/exercises/practice/matching-brackets/.meta/test_template.erb b/exercises/practice/matching-brackets/.meta/test_template.erb
new file mode 100644
index 0000000000..3b7324719b
--- /dev/null
+++ b/exercises/practice/matching-brackets/.meta/test_template.erb
@@ -0,0 +1,11 @@
+require 'minitest/autorun'
+require_relative 'matching_brackets'
+
+class MatchingBracketsTest < Minitest::Test
+<% json["cases"].each do |cases| %>
+    def test_<%= underscore(cases["description"]) %>
+        <%= skip? %>
+        <%= cases["expected"] ? "assert" : "refute" %> Brackets.paired?('<%= cases["input"]["value"] %>')
+    end
+    <% end %>
+end
diff --git a/exercises/practice/matching-brackets/matching_brackets_test.rb b/exercises/practice/matching-brackets/matching_brackets_test.rb
index cb8c5759cf..f9cd91c09b 100644
--- a/exercises/practice/matching-brackets/matching_brackets_test.rb
+++ b/exercises/practice/matching-brackets/matching_brackets_test.rb
@@ -4,101 +4,101 @@
 class MatchingBracketsTest < Minitest::Test
   def test_paired_square_brackets
     # skip
-    assert Brackets.paired?("[]")
+    assert Brackets.paired?('[]')
   end
 
   def test_empty_string
     skip
-    assert Brackets.paired?("")
+    assert Brackets.paired?('')
   end
 
   def test_unpaired_brackets
     skip
-    refute Brackets.paired?("[[")
+    refute Brackets.paired?('[[')
   end
 
   def test_wrong_ordered_brackets
     skip
-    refute Brackets.paired?("}{")
+    refute Brackets.paired?('}{')
   end
 
   def test_wrong_closing_bracket
     skip
-    refute Brackets.paired?("{]")
+    refute Brackets.paired?('{]')
   end
 
   def test_paired_with_whitespace
     skip
-    assert Brackets.paired?("{ }")
+    assert Brackets.paired?('{ }')
   end
 
   def test_partially_paired_brackets
     skip
-    refute Brackets.paired?("{[])")
+    refute Brackets.paired?('{[])')
   end
 
   def test_simple_nested_brackets
     skip
-    assert Brackets.paired?("{[]}")
+    assert Brackets.paired?('{[]}')
   end
 
   def test_several_paired_brackets
     skip
-    assert Brackets.paired?("{}[]")
+    assert Brackets.paired?('{}[]')
   end
 
   def test_paired_and_nested_brackets
     skip
-    assert Brackets.paired?("([{}({}[])])")
+    assert Brackets.paired?('([{}({}[])])')
   end
 
   def test_unopened_closing_brackets
     skip
-    refute Brackets.paired?("{[)][]}")
+    refute Brackets.paired?('{[)][]}')
   end
 
   def test_unpaired_and_nested_brackets
     skip
-    refute Brackets.paired?("([{])")
+    refute Brackets.paired?('([{])')
   end
 
   def test_paired_and_wrong_nested_brackets
     skip
-    refute Brackets.paired?("[({]})")
+    refute Brackets.paired?('[({]})')
   end
 
   def test_paired_and_wrong_nested_brackets_but_innermost_are_correct
     skip
-    refute Brackets.paired?("[({}])")
+    refute Brackets.paired?('[({}])')
   end
 
   def test_paired_and_incomplete_brackets
     skip
-    refute Brackets.paired?("{}[")
+    refute Brackets.paired?('{}[')
   end
 
   def test_too_many_closing_brackets
     skip
-    refute Brackets.paired?("[]]")
+    refute Brackets.paired?('[]]')
   end
 
   def test_early_unexpected_brackets
     skip
-    refute Brackets.paired?(")()")
+    refute Brackets.paired?(')()')
   end
 
   def test_early_mismatched_brackets
     skip
-    refute Brackets.paired?("{)()")
+    refute Brackets.paired?('{)()')
   end
 
   def test_math_expression
     skip
-    assert Brackets.paired?("(((185 + 223.85) * 15) - 543)/2")
+    assert Brackets.paired?('(((185 + 223.85) * 15) - 543)/2')
   end
 
   def test_complex_latex_expression
     skip
-    assert Brackets.paired?("\left(\begin{array}{cc} \frac{1}{3} & x\ \mathrm{e}^{x} &... x^2 \end{array}\right)")
+    assert Brackets.paired?('\left(\begin{array}{cc} \frac{1}{3} & x\\ \mathrm{e}^{x} &... x^2 \end{array}\right)')
   end
 end
diff --git a/exercises/practice/matrix/.meta/test_template.erb b/exercises/practice/matrix/.meta/test_template.erb
new file mode 100644
index 0000000000..5a67b63f01
--- /dev/null
+++ b/exercises/practice/matrix/.meta/test_template.erb
@@ -0,0 +1,12 @@
+require 'minitest/autorun'
+require_relative 'matrix'
+
+class MatrixTest < Minitest::Test
+<% json["cases"].each do |cases| %>
+    def test_<%= underscore(cases["description"]) %>
+        <%= skip? %>
+        matrix = Matrix.new(<%= cases["input"]["string"].inspect %>)
+        assert_equal <%= cases["expected"] %>, matrix.<%= cases["property"] %>(<%= cases["input"]["index"] %>)
+    end
+    <% end %>
+end