Spec generators for square-root, sum-of-multiples, two-fer

exercises/practice/space-age/.meta/spec_generator.lua

@@ -2,8 +2,6 @@ return {
   module_name = 'SpaceAge',
 
   generate_test = function(case)
-    require'pl.pretty'.dump(case)
-
     if type(case.expected) == 'table' then
       local template = [[
       local age = SpaceAge:new(%s)

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

@@ -0,0 +1,12 @@
+local utils = require 'utils'
+
+return {
+  module_name = 'SquareRoot',
+
+  generate_test = function(case)
+    local template = [[
+      assert.equal(%s, SquareRoot.%s(%s))]]
+
+    return template:format(tostring(case.expected), utils.snake_case(case.property), case.input.radicand)
+  end
+}

exercises/practice/square-root/square-root_spec.lua

@@ -1,4 +1,4 @@
-local SquareRoot = require 'square-root'
+local SquareRoot = require('square-root')
 
 describe('square-root', function()
   it('root of 1', function()

exercises/practice/sum-of-multiples/.meta/example.lua

@@ -6,7 +6,7 @@ return function(numbers)
 
       for candidate = 1, limit - 1 do
         for _, number in ipairs(numbers) do
-          if candidate % number == 0 then
+          if number ~= 0 and candidate % number == 0 then
             multiples[candidate] = true
           end
         end

exercises/practice/sum-of-multiples/.meta/spec_generator.lua

@@ -0,0 +1,13 @@
+local utils = require 'utils'
+
+return {
+  module_name = 'sum_of_multiples',
+
+  generate_test = function(case)
+    local template = [[
+      assert.equal(%s, sum_of_multiples(%s).to(%s))]]
+
+    local factors = '{ ' .. table.concat(utils.map(case.input.factors, tostring), ', ') .. ' }'
+    return template:format(tostring(case.expected), factors, case.input.limit)
+  end
+}

exercises/practice/sum-of-multiples/sum-of-multiples_spec.lua

@@ -1,24 +1,67 @@
 local sum_of_multiples = require('sum-of-multiples')
 
 describe('sum-of-multiples', function()
-  it('should sum multiples of a single number', function()
-    assert.same(9, sum_of_multiples({ 3 }).to(7))
-    assert.same(15, sum_of_multiples({ 5 }).to(12))
+  it('no multiples within limit', function()
+    assert.equal(0, sum_of_multiples({ 3, 5 }).to(1))
   end)
 
-  it('should sum multiples of a list of numbers', function()
-    assert.same(33, sum_of_multiples({ 3, 5 }).to(11))
-    assert.same(129, sum_of_multiples({ 7, 3 }).to(25))
-    assert.same(153, sum_of_multiples({ 7, 3, 8 }).to(25))
+  it('one factor has multiples within limit', function()
+    assert.equal(3, sum_of_multiples({ 3, 5 }).to(4))
   end)
 
-  it('should calculate multiples up to, but not including, the limit', function()
-    assert.same(9, sum_of_multiples({ 3 }).to(9))
-    assert.same(23, sum_of_multiples({ 3, 5 }).to(10))
+  it('more than one multiple within limit', function()
+    assert.equal(9, sum_of_multiples({ 3 }).to(7))
   end)
 
-  it('should not include a multiple more than once', function()
-    assert.same(35, sum_of_multiples({ 2, 5 }).to(11))
-    assert.same(sum_of_multiples({ 2 }).to(11), sum_of_multiples({ 2, 4 }).to(11))
+  it('more than one factor with multiples within limit', function()
+    assert.equal(23, sum_of_multiples({ 3, 5 }).to(10))
+  end)
+
+  it('each multiple is only counted once', function()
+    assert.equal(2318, sum_of_multiples({ 3, 5 }).to(100))
+  end)
+
+  it('a much larger limit', function()
+    assert.equal(233168, sum_of_multiples({ 3, 5 }).to(1000))
+  end)
+
+  it('three factors', function()
+    assert.equal(51, sum_of_multiples({ 7, 13, 17 }).to(20))
+  end)
+
+  it('factors not relatively prime', function()
+    assert.equal(30, sum_of_multiples({ 4, 6 }).to(15))
+  end)
+
+  it('some pairs of factors relatively prime and some not', function()
+    assert.equal(4419, sum_of_multiples({ 5, 6, 8 }).to(150))
+  end)
+
+  it('one factor is a multiple of another', function()
+    assert.equal(275, sum_of_multiples({ 5, 25 }).to(51))
+  end)
+
+  it('much larger factors', function()
+    assert.equal(2203160, sum_of_multiples({ 43, 47 }).to(10000))
+  end)
+
+  it('all numbers are multiples of 1', function()
+    assert.equal(4950, sum_of_multiples({ 1 }).to(100))
+  end)
+
+  it('no factors means an empty sum', function()
+    assert.equal(0, sum_of_multiples({}).to(10000))
+  end)
+
+  it('the only multiple of 0 is 0', function()
+    assert.equal(0, sum_of_multiples({ 0 }).to(1))
+  end)
+
+  it('the factor 0 does not affect the sum of multiples of other factors', function()
+    assert.equal(3, sum_of_multiples({ 3, 0 }).to(4))
+  end)
+
+  it('solutions using include-exclude must extend to cardinality greater than 3', function()
+    assert.equal(39614537, sum_of_multiples({ 2, 3, 5, 7, 11 }).to(10000))
   end)
 end)

exercises/practice/two-fer/.meta/spec_generator.lua

@@ -0,0 +1,13 @@
+local utils = require 'utils'
+
+return {
+  module_name = 'TwoFer',
+
+  generate_test = function(case)
+    local template = [[
+      assert.equal(%s, TwoFer.%s(%s))]]
+
+    local name = case.input.name and utils.stringify(case.input.name) or ''
+    return template:format(utils.stringify(case.expected), utils.snake_case(case.property), name)
+  end
+}

exercises/practice/two-fer/two-fer_spec.lua

@@ -1,4 +1,4 @@
-local TwoFer = require 'two-fer'
+local TwoFer = require('two-fer')
 
 describe('two-fer', function()
   it('no name given', function()