local moduleName = 'Math/sandbox' -- assigning this to a variable as it is later used to generate an #invoke statement.

local mm = require('Module:' .. moduleName)

local ScribuntoUnit = require('Module:ScribuntoUnit')

local suite = ScribuntoUnit:new()

function suite.getLuaResult(funcName, args)

args = args or {}

local result = mm['_' .. funcName](unpack(args))

return result

end

function suite:assertLuaEquals(expected, funcName, args)

args = args or {}

self:assertEquals(expected, self.getLuaResult(funcName, args))

end

function suite.buildInvocation(funcName, args)

args = args or {}

local argsClone = mw.clone(args)

-- Build a module invocation equivalent to the args table. Taken from Unsubst.

-- Numbered args first.

local ret = '{{#invoke:' .. moduleName .. '|' .. funcName

for k, v in ipairs(argsClone) do

v = tostring(v)

if string.find(v, '=', 1, true) then

-- likely something like 1=foo=bar, we need to do it as a named arg

break

end

ret = ret .. '|' .. v

argsClone[k] = nil

end

for k, v in pairs(argsClone) do

k = tostring(k)

v = tostring(v)

ret = ret .. '|' .. k .. '=' .. v

end

return ret .. '}}'

end

function suite:getInvokeResult(funcName, args, convertNumber) -- Unless convertNumber is false, the number is converted to a number, if possible, on re-entry to Lua.

args = args or {}

local invocation = self.buildInvocation(funcName, args)

local result = self.frame:preprocess(invocation)

if convertNumber ~= false and tonumber(result) then

return tonumber(result)

else

return result

end

end

function suite:assertInvokeEquals(expected, funcName, args, convertNumber)

args = args or {}

local invokeResult = self:getInvokeResult(funcName, args, convertNumber)

self:assertEquals(expected, invokeResult)

end

function suite:assertLuaAndInvokeTrue(trueFunc, funcName, args, convertNumber)

args = args or {}

local invokeResult = self:getInvokeResult(funcName, args, convertNumber)

local luaResult = self.getLuaResult(funcName, args)

self:assertTrue(trueFunc(invokeResult))

self:assertTrue(trueFunc(luaResult))

end

function suite:assertLuaAndInvokeEqual(funcName, testTable, convertNumber)

local expected = testTable[1]

local args = testTable[2] or {}

self:assertLuaEquals(expected, funcName, args)

self:assertInvokeEquals(expected, funcName, args, convertNumber)

end

function suite:assertLuaAndInvokeEqualMany(funcName, testTables, convertNumber)

for i, testTable in ipairs(testTables) do

self:assertLuaAndInvokeEqual(funcName, testTable, convertNumber)

end

end

function suite:test_random()

self:assertLuaAndInvokeTrue(function (n) return n >= 0 and n < 1 end, 'random')

self:assertLuaAndInvokeTrue(function (n) return n == 1 or n == 2 end, 'random', {2})

self:assertLuaAndInvokeTrue(function (n) return n >= 1 and n <= 10 and math.floor(n) == n end, 'random', {10})

self:assertLuaAndInvokeTrue(function (n) return n >= 10 and n <= 20 and math.floor(n) == n end, 'random', {10, 20})

end

function suite:test_max()

local tests = {

{9, {5, 6, 9}},

{-5, {-5, -6, -9}},

}

self:assertLuaAndInvokeEqualMany('max', tests)

self:assertLuaEquals(nil, 'max', {})

self:assertInvokeEquals(, 'max', {})

end

function suite:test_average()

local tests = {

{6, {5, 6, 7}},

{-7, {-7}},

{10000000002, {10000000001, 10000000002, 10000000003}},

}

self:assertLuaAndInvokeEqualMany('average', tests)

end

function suite:test_min()

local tests = {

{1, {1, 2, 3}},

{-3, {-1, -2, -3}},

}

self:assertLuaAndInvokeEqualMany('min', tests)

self:assertLuaEquals(nil, 'min', {})

self:assertInvokeEquals(, 'min', {})

end

function suite:test_gcd()

local tests = {

{4, {12, 8}},

{2, {12, 8, 6}},

{4, {-12, -8}},

{2, {-12, -8, -6}},

{8, {0, 8}},

{8, {0, -8}},

{0, {0}},

{0, {0, 0}},

{4, {12, nil, 8}},

}

self:assertLuaAndInvokeEqualMany('gcd', tests)

end

function suite:test_order()

local tests = {

{0, {2}},

{1, {20}},

{2, {200}},

{0, {5}},

}

self:assertLuaAndInvokeEqualMany('order', tests)

self:assertInvokeEquals('Formatting error: order of magnitude input appears non-numeric', 'order', {'string'})

self:assertInvokeEquals(0, 'order', {x = 5})

end

function suite:test_precison()

local tests = {

{4, {1.9856}},

{1, {1.1}},

{10, {1.9999999999}},

}

self:assertLuaAndInvokeEqualMany('precision', tests)

self:assertInvokeEquals('Formatting error: precision input appears non-numeric', 'precision', {'letra'})

self:assertInvokeEquals(4, 'precision', {x = '1.9888'})

end

function suite:test_round()

local tests = {

{2, {1.99999}},

{2, {1.99999, 0}},

{1.9, {1.94, 1}},

{20, {15, -1}},

}

self:assertLuaAndInvokeEqualMany('round', tests)

self:assertInvokeEquals(3, 'round', {value = '2.99999', precision = '2'})

end

function suite:test_mod()

local tests = {

{0, {10, 2}},

{1, {11, 2}},

{0, {525000000000000120000000000, 3}}, -- With the plain % operator this returns 68719476736 due to floating point error.

}

self:assertLuaAndInvokeEqualMany('mod', tests)

self:assertInvokeEquals('Formatting error: first argument to mod appears non-numeric', 'mod', {})

self:assertInvokeEquals('Formatting error: second argument to mod appears non-numeric', 'mod', {1})

local successNoArgs = pcall(mm._mod)

self:assertFalse(successNoArgs)

local successOneArg = pcall(mm._mod, 1)

self:assertFalse(successOneArg)

end

function suite:test_precison_format()

local tests = {

{'10.00', {10, 2}}

}

self:assertLuaAndInvokeEqualMany('precision_format', tests, false) -- the "false" stops string values being converted to numbers on re-entry from #invoke.

end

function suite:assertCleanNumberEquals(expectedTable, inputString)

local expectedNum, expectedNumString = expectedTable[1], expectedTable[2]

local actualNum, actualNumString = mm._cleanNumber(inputString)

self:assertEquals(expectedNum, actualNum)

self:assertEquals(expectedNumString, actualNumString)

end

function suite:test_cleanNumber()

self:assertCleanNumberEquals({0, '0'}, '0')

self:assertCleanNumberEquals({1, '1'}, 1)

self:assertCleanNumberEquals({2, '2'}, ' 2 ')

self:assertCleanNumberEquals({3, '3'}, '4-1')

self:assertCleanNumberEquals({4, '4'}, '2 + 2')

self:assertCleanNumberEquals({5, '5'}, ' 2 + 3 ')

self:assertCleanNumberEquals({6, '6'}, '+6')

self:assertCleanNumberEquals({-7, '-7'}, '-7')

self:assertCleanNumberEquals({88, '88'}, '0x58')

self:assertCleanNumberEquals({1000000000, '1e+9'}, '1e+9')

self:assertCleanNumberEquals({-88, '-88'}, '-0x58')

self:assertCleanNumberEquals({0.16667, '0.16667'}, '1/6 round 5')

self:assertCleanNumberEquals({nil, nil}, '1 foo 2') -- invalid expression

self:assertCleanNumberEquals({nil, nil}, '1+') -- missing expr operand

self:assertCleanNumberEquals({nil, nil}, )

self:assertCleanNumberEquals({nil, nil}, ' ')

self:assertCleanNumberEquals({nil, nil}, 'string')

self:assertCleanNumberEquals({nil, nil}, ' string with padding ')

end

return suite

• Golden Dragon massacre
• Golden duck
• Golden Duck Award
• Golden eagle
• Golden Eagle (comics)
• Golden Eagle District
• Golden Eagles
• Golden Earing
• Golden Earring
• Golden Earring (album)
• Golden Ears Bridge
• Goldene Bistritz
• Golden Era Productions
• GoldenEye
• Goldeneye
• Golden Eye 007
• Goldeneye 007
• GoldenEye 007 (1997 video game)
• GoldenEye 007 (video game)
• Goldeneye (duck)
• GoldenEye (fictional satellite weapon)
• GoldenEye (film)
• GoldenEye (James Bond character)
• GoldenEye (movie)
• GoldenEye: Rogue Agent