Additional spec generators

bin/generate-spec

@@ -13,7 +13,7 @@ utils.map = function(t, f)
 end
 
 utils.stringify = function(s)
-  s = s:gsub('\n', '\\n')
+  s = s:gsub('\\', '\\\\'):gsub('\n', '\\n')
   if s:match("'") and not s:match('"') then
     return '"' .. s .. '"'
   else

exercises/practice/crypto-square/.meta/spec_generator.lua

@@ -0,0 +1,11 @@
+local utils = require 'utils'
+
+return {
+  module_name = 'crypto_square',
+
+  generate_test = function(case)
+    local template = [[
+      assert.are.equal(%s, crypto_square.ciphertext(%s))]]
+    return template:format(utils.stringify(case.expected), utils.stringify(case.input.plaintext))
+  end
+}

exercises/practice/crypto-square/crypto-square_spec.lua

@@ -9,15 +9,15 @@ describe('crypto-square', function()
     assert.are.equal('', crypto_square.ciphertext('... --- ...'))
   end)
 
-  it('Lowercase', function()
+  it('lowercase', function()
     assert.are.equal('a', crypto_square.ciphertext('A'))
   end)
 
-  it('Remove spaces', function()
+  it('remove spaces', function()
     assert.are.equal('b', crypto_square.ciphertext('  b '))
   end)
 
-  it('Remove punctuation', function()
+  it('remove punctuation', function()
     assert.are.equal('1', crypto_square.ciphertext('@1,%!'))
   end)
 

exercises/practice/knapsack/.meta/spec_generator.lua

@@ -0,0 +1,20 @@
+local utils = require 'utils'
+
+local function render_items(items)
+  return table.concat(utils.map(items, function(item)
+    return ('{ weight = %d, value = %d }'):format(item.weight, item.value)
+  end), ', ')
+end
+
+return {
+  module_name = 'knapsack',
+
+  generate_test = function(case)
+    local template = [[
+      local items = { %s }
+      local maximum_weight = %d
+
+      assert.are.equal(%d, knapsack.maximum_value(maximum_weight, items))]]
+    return template:format(render_items(case.input.items), case.input.maximumWeight, case.expected)
+  end
+}

exercises/practice/knapsack/knapsack_spec.lua

@@ -1,20 +1,21 @@
-local knapsack = require 'knapsack'
+local knapsack = require('knapsack')
 
 describe('knapsack', function()
   it('no items', function()
     local items = {}
     local maximum_weight = 100
+
     assert.are.equal(0, knapsack.maximum_value(maximum_weight, items))
   end)
 
-  it('one item too heavy', function()
+  it('one item, too heavy', function()
     local items = { { weight = 100, value = 1 } }
     local maximum_weight = 10
 
     assert.are.equal(0, knapsack.maximum_value(maximum_weight, items))
   end)
 
-  it('five items cannot be greedy by weight', function()
+  it('five items (cannot be greedy by weight)', function()
     local items = {
       { weight = 2, value = 5 },
       { weight = 2, value = 5 },
@@ -27,7 +28,7 @@ describe('knapsack', function()
     assert.are.equal(21, knapsack.maximum_value(maximum_weight, items))
   end)
 
-  it('five items cannot be greedy by value', function()
+  it('five items (cannot be greedy by value)', function()
     local items = {
       { weight = 2, value = 20 },
       { weight = 2, value = 20 },
@@ -52,9 +53,8 @@ describe('knapsack', function()
     assert.are.equal(90, knapsack.maximum_value(maximum_weight, items))
   end)
 
-  it('eight items', function()
+  it('8 items', function()
     local items = {
-      { weight = 5, value = 10 },
       { weight = 25, value = 350 },
       { weight = 35, value = 400 },
       { weight = 45, value = 450 },
@@ -69,7 +69,7 @@ describe('knapsack', function()
     assert.are.equal(900, knapsack.maximum_value(maximum_weight, items))
   end)
 
-  it('fifteen items', function()
+  it('15 items', function()
     local items = {
       { weight = 70, value = 135 },
       { weight = 73, value = 139 },

exercises/practice/matching-brackets/.meta/spec_generator.lua

@@ -0,0 +1,11 @@
+local utils = require 'utils'
+
+return {
+  module_name = 'brackets',
+
+  generate_test = function(case)
+    local template = [[
+      assert.is_%s(brackets.valid(%s))]]
+    return template:format(case.expected, utils.stringify(case.input.value))
+  end
+}

exercises/practice/matching-brackets/matching-brackets_spec.lua

@@ -1,85 +1,84 @@
--- canonical test data 2.0.0
 local brackets = require('matching-brackets')
 
 describe('matching-brackets', function()
-  it('should accept paired square brackets', function()
+  it('paired square brackets', function()
     assert.is_true(brackets.valid('[]'))
   end)
 
-  it('should accept empty string', function()
+  it('empty string', function()
     assert.is_true(brackets.valid(''))
   end)
 
-  it('should reject unpaired brackets', function()
+  it('unpaired brackets', function()
     assert.is_false(brackets.valid('[['))
   end)
 
-  it('should reject wrong ordered brackets', function()
+  it('wrong ordered brackets', function()
     assert.is_false(brackets.valid('}{'))
   end)
 
-  it('should reject wrong closing bracket', function()
+  it('wrong closing bracket', function()
     assert.is_false(brackets.valid('{]'))
   end)
 
-  it('should accept paired with whitespace', function()
+  it('paired with whitespace', function()
     assert.is_true(brackets.valid('{ }'))
   end)
 
-  it('should reject partially paired brackets', function()
+  it('partially paired brackets', function()
     assert.is_false(brackets.valid('{[])'))
   end)
 
-  it('should accept simple nested brackets', function()
+  it('simple nested brackets', function()
     assert.is_true(brackets.valid('{[]}'))
   end)
 
-  it('should accept several paired brackets', function()
+  it('several paired brackets', function()
     assert.is_true(brackets.valid('{}[]'))
   end)
 
-  it('should accept paired and nested brackets', function()
+  it('paired and nested brackets', function()
     assert.is_true(brackets.valid('([{}({}[])])'))
   end)
 
-  it('should reject unopened closing brackets', function()
+  it('unopened closing brackets', function()
     assert.is_false(brackets.valid('{[)][]}'))
   end)
 
-  it('should reject unpaired and nested brackets', function()
+  it('unpaired and nested brackets', function()
     assert.is_false(brackets.valid('([{])'))
   end)
 
-  it('should reject paired and wrong nested brackets', function()
+  it('paired and wrong nested brackets', function()
     assert.is_false(brackets.valid('[({]})'))
   end)
 
-  it('should reject paired and wrong nested brackets but innermost are correct', function()
+  it('paired and wrong nested brackets but innermost are correct', function()
     assert.is_false(brackets.valid('[({}])'))
   end)
 
-  it('should reject paired and incomplete brackets', function()
+  it('paired and incomplete brackets', function()
     assert.is_false(brackets.valid('{}['))
   end)
 
-  it('should reject too many closing brackets', function()
+  it('too many closing brackets', function()
     assert.is_false(brackets.valid('[]]'))
   end)
 
-  it('should reject early unexpected brackets', function()
+  it('early unexpected brackets', function()
     assert.is_false(brackets.valid(')()'))
   end)
 
-  it('should reject early mismatched brackets', function()
+  it('early mismatched brackets', function()
     assert.is_false(brackets.valid('{)()'))
   end)
 
-  it('should accept math expression', function()
+  it('math expression', function()
     assert.is_true(brackets.valid('(((185 + 223.85) * 15) - 543)/2'))
   end)
 
-  it('should accept complex latex expression', function()
+  it('complex latex expression', function()
     assert.is_true(brackets.valid(
-                     [[\left(\begin{array}{cc} \frac{1}{3} & x\\ \mathrm{e}^{x} &... x^2 \end{array}\right)]]))
+                     '\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)'))
   end)
 end)

exercises/practice/pythagorean-triplet/.meta/spec_generator.lua

@@ -0,0 +1,26 @@
+local utils = require 'utils'
+
+local function render_triplets(triplets)
+  return '{ ' .. table.concat(utils.map(triplets, function(triplet)
+    return '{ ' .. table.concat(triplet, ', ') .. ' }'
+  end), ', ') .. ' }'
+end
+
+return {
+  module_name = 'triplets_with_sum',
+
+  test_helpers = [[
+    local function sort(triplets)
+      table.sort(triplets, function(a, b)
+        return a[1] < b[1]
+      end)
+      return triplets
+    end
+  ]],
+
+  generate_test = function(case)
+    local template = [[
+      assert.same(%s, sort(triplets_with_sum(%d)))]]
+    return template:format(render_triplets(case.expected), case.input.n)
+  end
+}

exercises/practice/pythagorean-triplet/pythagorean-triplet_spec.lua

@@ -8,48 +8,46 @@ describe('pythagorean-triplet', function()
     return triplets
   end
 
-  describe('triplets_with_sum', function()
-    it('finds triplets whose sum is 12', function()
-      assert.same({ { 3, 4, 5 } }, sort(triplets_with_sum(12)))
-    end)
+  it('triplets whose sum is 12', function()
+    assert.same({ { 3, 4, 5 } }, sort(triplets_with_sum(12)))
+  end)
 
-    it('finds triplets whose sum is 108', function()
-      assert.same({ { 27, 36, 45 } }, sort(triplets_with_sum(108)))
-    end)
+  it('triplets whose sum is 108', function()
+    assert.same({ { 27, 36, 45 } }, sort(triplets_with_sum(108)))
+  end)
 
-    it('finds triplets whose sum is 1000', function()
-      assert.same({ { 200, 375, 425 } }, sort(triplets_with_sum(1000)))
-    end)
+  it('triplets whose sum is 1000', function()
+    assert.same({ { 200, 375, 425 } }, sort(triplets_with_sum(1000)))
+  end)
 
-    it('finds no triplets whose sum is 1001', function()
-      assert.same({}, triplets_with_sum(1001))
-    end)
+  it('no matching triplets for 1001', function()
+    assert.same({}, sort(triplets_with_sum(1001)))
+  end)
 
-    it('finds triplets whose sum is 90', function()
-      assert.same({ { 9, 40, 41 }, { 15, 36, 39 } }, sort(triplets_with_sum(90)))
-    end)
+  it('returns all matching triplets', function()
+    assert.same({ { 9, 40, 41 }, { 15, 36, 39 } }, sort(triplets_with_sum(90)))
+  end)
 
-    it('finds triplets whose sum is 840', function()
-      assert.same({
-        { 40, 399, 401 },
-        { 56, 390, 394 },
-        { 105, 360, 375 },
-        { 120, 350, 370 },
-        { 140, 336, 364 },
-        { 168, 315, 357 },
-        { 210, 280, 350 },
-        { 240, 252, 348 }
-      }, sort(triplets_with_sum(840)))
-    end)
+  it('several matching triplets', function()
+    assert.same({
+      { 40, 399, 401 },
+      { 56, 390, 394 },
+      { 105, 360, 375 },
+      { 120, 350, 370 },
+      { 140, 336, 364 },
+      { 168, 315, 357 },
+      { 210, 280, 350 },
+      { 240, 252, 348 }
+    }, sort(triplets_with_sum(840)))
+  end)
 
-    it('finds triplets whose sum is a large number (30000)', function()
-      assert.same({
-        { 1200, 14375, 14425 },
-        { 1875, 14000, 14125 },
-        { 5000, 12000, 13000 },
-        { 6000, 11250, 12750 },
-        { 7500, 10000, 12500 }
-      }, sort(triplets_with_sum(30000)))
-    end)
+  it('triplets for large number', function()
+    assert.same({
+      { 1200, 14375, 14425 },
+      { 1875, 14000, 14125 },
+      { 5000, 12000, 13000 },
+      { 6000, 11250, 12750 },
+      { 7500, 10000, 12500 }
+    }, sort(triplets_with_sum(30000)))
   end)
 end)

exercises/practice/queen-attack/.meta/spec_generator.lua

@@ -0,0 +1,24 @@
+local function render_queen(queen)
+  return ('Queen({ row = %d, column = %d })'):format(queen.position.row, queen.position.column)
+end
+
+return {
+  module_name = 'Queen',
+
+  generate_test = function(case)
+    if case.property == 'create' then
+      local template = [[
+        assert.%s(function()
+          %s
+        end)]]
+      local assertion = type(case.expected) == 'table' and 'has_error' or 'has_no_error'
+      return template:format(assertion, render_queen(case.input.queen))
+    else
+      local template = [[
+        local q1 = %s
+        local q2 = %s
+        assert.is_%s(q1.can_attack(q2))]]
+      return template:format(render_queen(case.input.white_queen), render_queen(case.input.black_queen), case.expected)
+    end
+  end
+}