-- Unit tests for [[Module:Math/sandbox]]. Click talk page to run tests.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()--------------------------------------------------------------------------------- Helper functions-------------------------------------------------------------------------------function suite.err(msg) return mw.ustring.format('<strong class="error">Lỗi định dạng: %s</strong>', msg)endfunction suite.getLuaResult(funcName, args) args = args or {} local result = mm['_' .. funcName](unpack(args)) return resultendfunction suite:assertLuaEquals(expected, funcName, args) args = args or {} self:assertEquals(expected, self.getLuaResult(funcName, args))endfunction suite.buildInvocation(funcName, args) args = args or {} local argsClone = mw.clone(args) -- Build a module invocation equivalent to the args table. Taken from [[Module: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 .. '}}'endfunction 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 endendfunction suite:assertInvokeEquals(expected, funcName, args, convertNumber) args = args or {} local invokeResult = self:getInvokeResult(funcName, args, convertNumber) self:assertEquals(expected, invokeResult)endfunction 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))endfunction 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)endfunction suite:assertLuaAndInvokeEqualMany(funcName, testTables, convertNumber) for i, testTable in ipairs(testTables) do self:assertLuaAndInvokeEqual(funcName, testTable, convertNumber) endend--------------------------------------------------------------------------------- Test random-------------------------------------------------------------------------------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--------------------------------------------------------------------------------- Test max------------------------------------------------------------------------------- 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--------------------------------------------------------------------------------- Test average-------------------------------------------------------------------------------function suite:test_average() local tests = { {6, {5, 6, 7}}, {-7, {-7}}, {10000000002, {10000000001, 10000000002, 10000000003}}, } self:assertLuaAndInvokeEqualMany('average', tests)end --------------------------------------------------------------------------------- Test min-------------------------------------------------------------------------------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--------------------------------------------------------------------------------- Test gcd-------------------------------------------------------------------------------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--------------------------------------------------------------------------------- Test order-------------------------------------------------------------------------------function suite:test_order() local tests = { {0, {2}}, {1, {20}}, {2, {200}}, {0, {5}}, } self:assertLuaAndInvokeEqualMany('order', tests) self:assertInvokeEquals(suite.err('giá trị đối số đầu tiên lấy dư không phải là số'), 'order', {'string'}) self:assertInvokeEquals(0, 'order', {x = 5})end--------------------------------------------------------------------------------- Test precision-------------------------------------------------------------------------------function suite:test_precison() local tests = { {4, {1.9856}}, {1, {1.1}}, {10, {1.9999999999}}, {9, {0.000020004}}, } self:assertLuaAndInvokeEqualMany('precision', tests) self:assertInvokeEquals(suite.err('giá trị cho vào hàm độ chính xác không phải là số'), 'precision', {'letra'}) self:assertInvokeEquals(4, 'precision', {x = '1.9888'})end--------------------------------------------------------------------------------- Test round-------------------------------------------------------------------------------function suite:test_round() local tests = { {2, {1.99999}}, {2, {1.99999, 0}}, {1.9, {1.94, 1}}, {20, {15, -1}}, {2.0004e-05, {0.000020004}}, -- broken and returns 0 due to limit of order -5 of phps floating number {2.0004e-05, {0.000020004, mm._precision(0.000020004)}}, -- works } self:assertLuaAndInvokeEqualMany('round', tests) self:assertInvokeEquals(3, 'round', {value = '2.99999', precision = '2'})end--------------------------------------------------------------------------------- Test mod-------------------------------------------------------------------------------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(suite.err('giá trị đối số đầu tiên lấy dư không phải là số'), 'mod', {}) self:assertInvokeEquals(suite.err('giá trị đối số thứ hai lấy dư không phải là số'), 'mod', {1}) local successNoArgs = pcall(mm._mod) self:assertFalse(successNoArgs) local successOneArg = pcall(mm._mod, 1) self:assertFalse(successOneArg)end--------------------------------------------------------------------------------- Test precision format-------------------------------------------------------------------------------function suite:test_precison_format() local tests = { {'10.00', {10, 2}}, {'2.00<span style="margin:0 .15em 0 .25em">×</span>10<sup>−5</sup>', {0.000020004, 7}} } self:assertLuaAndInvokeEqualMany('precision_format', tests, false) -- the "false" stops string values being converted to numbers on re-entry from #invoke.end--------------------------------------------------------------------------------- Test cleanNumber-------------------------------------------------------------------------------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)endfunction 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--------------------------------------------------------------------------------- Test divide-------------------------------------------------------------------------------function suite:test_divide() self:assertInvokeEquals('1','divide',{1, 2, round = 'yes'}, false) self:assertInvokeEquals('0.5','divide',{1, 2, round = 'no'}, false) self:assertInvokeEquals('0','divide',{1, 3, round = 'yes', precision=2}, false) self:assertInvokeEquals('0.33','divide',{1, 3, precision=2}, false) self:assertInvokeEquals(suite.err('Không có số bị chia'),'divide',{'',2},false) self:assertInvokeEquals(suite.err('Không có số chia'),'divide',{1,''},false) self:assertInvokeEquals(suite.err('Không có số chia'),'divide',{},false) self:assertInvokeEquals(suite.err('Không có số chia'),'divide',{'',''},false) self:assertInvokeEquals(suite.err('Không phải là số: a'),'divide',{'a',2},false) self:assertInvokeEquals(suite.err('Không phải là số: b'),'divide',{1,'b'},false) self:assertInvokeEquals(suite.err('Không phải là số: b'),'divide',{'a','b'},false) self:assertInvokeEquals('<big>Bad</big>','divide',{'<big>Bad</big>',2},false) self:assertInvokeEquals('<big>Bad</big>','divide',{1,'<big>Bad</big>'},false) self:assertInvokeEquals('<big>Bad2</big>','divide',{'<big>Bad1</big>','<big>Bad2</big>'},false)endreturn suite
