-- Unit tests for [[Module:Math/sandbox]]. Click talk page to run tests.localmoduleName='Math/sandbox'-- assigning this to a variable as it is later used to generate an #invoke statement.localmm=require('Module:'..moduleName)localScribuntoUnit=require('Module:ScribuntoUnit')localsuite=ScribuntoUnit:new()--------------------------------------------------------------------------------- Helper functions-------------------------------------------------------------------------------functionsuite.err(msg)returnmw.ustring.format('<strong class="error">Formatting error: %s</strong>',msg)endfunctionsuite.getLuaResult(funcName,args)args=argsor{}localresult=mm['_'..funcName](unpack(args))returnresultendfunctionsuite:assertLuaEquals(expected,funcName,args)args=argsor{}self:assertEquals(expected,self.getLuaResult(funcName,args))endfunctionsuite.buildInvocation(funcName,args)args=argsor{}localargsClone=mw.clone(args)-- Build a module invocation equivalent to the args table. Taken from [[Module:Unsubst]].-- Numbered args first.localret='{{#invoke:'..moduleName..'|'..funcNamefork,vinipairs(argsClone)dov=tostring(v)ifstring.find(v,'=',1,true)then-- likely something like 1=foo=bar, we need to do it as a named argbreakendret=ret..'|'..vargsClone[k]=nilendfork,vinpairs(argsClone)dok=tostring(k)v=tostring(v)ret=ret..'|'..k..'='..vendreturnret..'}}'endfunctionsuite:getInvokeResult(funcName,args,convertNumber)-- Unless convertNumber is false, the number is converted to a number, if possible, on re-entry to Lua.args=argsor{}localinvocation=self.buildInvocation(funcName,args)localresult=self.frame:preprocess(invocation)ifconvertNumber~=falseandtonumber(result)thenreturntonumber(result)elsereturnresultendendfunctionsuite:assertInvokeEquals(expected,funcName,args,convertNumber)args=argsor{}localinvokeResult=self:getInvokeResult(funcName,args,convertNumber)self:assertEquals(expected,invokeResult)endfunctionsuite:assertLuaAndInvokeTrue(trueFunc,funcName,args,convertNumber)args=argsor{}localinvokeResult=self:getInvokeResult(funcName,args,convertNumber)localluaResult=self.getLuaResult(funcName,args)self:assertTrue(trueFunc(invokeResult))self:assertTrue(trueFunc(luaResult))endfunctionsuite:assertLuaAndInvokeEqual(funcName,testTable,convertNumber)localexpected=testTable[1]localargs=testTable[2]or{}self:assertLuaEquals(expected,funcName,args)self:assertInvokeEquals(expected,funcName,args,convertNumber)endfunctionsuite:assertLuaAndInvokeEqualMany(funcName,testTables,convertNumber)fori,testTableinipairs(testTables)doself:assertLuaAndInvokeEqual(funcName,testTable,convertNumber)endend--------------------------------------------------------------------------------- Test random-------------------------------------------------------------------------------functionsuite:test_random()self:assertLuaAndInvokeTrue(function(n)returnn>=0andn<1end,'random')self:assertLuaAndInvokeTrue(function(n)returnn==1orn==2end,'random',{2})self:assertLuaAndInvokeTrue(function(n)returnn>=1andn<=10andmath.floor(n)==nend,'random',{10})self:assertLuaAndInvokeTrue(function(n)returnn>=10andn<=20andmath.floor(n)==nend,'random',{10,20})end--------------------------------------------------------------------------------- Test max-------------------------------------------------------------------------------functionsuite:test_max()localtests={{9,{5,6,9}},{-5,{-5,-6,-9}},}self:assertLuaAndInvokeEqualMany('max',tests)self:assertLuaEquals(nil,'max',{})self:assertInvokeEquals('','max',{})end--------------------------------------------------------------------------------- Test average-------------------------------------------------------------------------------functionsuite:test_average()localtests={{6,{5,6,7}},{-7,{-7}},{10000000002,{10000000001,10000000002,10000000003}},}self:assertLuaAndInvokeEqualMany('average',tests)end--------------------------------------------------------------------------------- Test min-------------------------------------------------------------------------------functionsuite:test_min()localtests={{1,{1,2,3}},{-3,{-1,-2,-3}},}self:assertLuaAndInvokeEqualMany('min',tests)self:assertLuaEquals(nil,'min',{})self:assertInvokeEquals('','min',{})end--------------------------------------------------------------------------------- Test gcd-------------------------------------------------------------------------------functionsuite:test_gcd()localtests={{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-------------------------------------------------------------------------------functionsuite:test_order()localtests={{0,{2}},{1,{20}},{2,{200}},{0,{5}},}self:assertLuaAndInvokeEqualMany('order',tests)self:assertInvokeEquals(suite.err('order of magnitude input appears non-numeric'),'order',{'string'})self:assertInvokeEquals(0,'order',{x=5})end--------------------------------------------------------------------------------- Test precision-------------------------------------------------------------------------------functionsuite:test_precison()localtests={{4,{1.9856}},{1,{1.1}},{10,{1.9999999999}},{9,{0.000020004}},}self:assertLuaAndInvokeEqualMany('precision',tests)self:assertInvokeEquals(suite.err('precision input appears non-numeric'),'precision',{'letra'})self:assertInvokeEquals(4,'precision',{x='1.9888'})end--------------------------------------------------------------------------------- Test round-------------------------------------------------------------------------------functionsuite:test_round()localtests={{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-------------------------------------------------------------------------------functionsuite:test_mod()localtests={{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('first argument to mod appears non-numeric'),'mod',{})self:assertInvokeEquals(suite.err('second argument to mod appears non-numeric'),'mod',{1})localsuccessNoArgs=pcall(mm._mod)self:assertFalse(successNoArgs)localsuccessOneArg=pcall(mm._mod,1)self:assertFalse(successOneArg)end--------------------------------------------------------------------------------- Test precision format-------------------------------------------------------------------------------functionsuite:test_precison_format()localtests={{'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-------------------------------------------------------------------------------functionsuite:assertCleanNumberEquals(expectedTable,inputString)localexpectedNum,expectedNumString=expectedTable[1],expectedTable[2]localactualNum,actualNumString=mm._cleanNumber(inputString)self:assertEquals(expectedNum,actualNum)self:assertEquals(expectedNumString,actualNumString)endfunctionsuite: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 expressionself:assertCleanNumberEquals({nil,nil},'1+')-- missing expr operandself:assertCleanNumberEquals({nil,nil},'')self:assertCleanNumberEquals({nil,nil},' ')self:assertCleanNumberEquals({nil,nil},'string')self:assertCleanNumberEquals({nil,nil},' string with padding ')end--------------------------------------------------------------------------------- Test divide-------------------------------------------------------------------------------functionsuite: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('Empty dividend'),'divide',{'',2},false)self:assertInvokeEquals(suite.err('Empty divisor'),'divide',{1,''},false)self:assertInvokeEquals(suite.err('Empty divisor'),'divide',{},false)self:assertInvokeEquals(suite.err('Empty divisor'),'divide',{'',''},false)self:assertInvokeEquals(suite.err('Not a number: a'),'divide',{'a',2},false)self:assertInvokeEquals(suite.err('Not a number: b'),'divide',{1,'b'},false)self:assertInvokeEquals(suite.err('Not a number: 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)endreturnsuite
