-- Unit tests for [[Module:TableTools]]. Click talk page to run tests.localtt=require('Module:TableTools/sandbox')-- the module to be testedlocalScribuntoUnit=require('Module:ScribuntoUnit')localsuite=ScribuntoUnit:new()-------------------------------------------------------------------------- Helper functions------------------------------------------------------------------------functionsuite.concatIpairs(t)localret=''fori,vinipairs(t)doret=ret..tostring(v)endreturnretendsuite.isNan=tt.isNanfunctionsuite:assertErrorEquals(expected,func,...)localsuccess,msg=pcall(func,...)self:assertEquals(expected,msg)endfunctionsuite:assertTypeErrorEquals(argId,name,expectedType,actualType,func,...)localexpected="bad argument #%d to '%s' (%s expected, got %s)"expected=expected:format(argId,name,expectedType,actualType)self:assertErrorEquals(expected,func,...)end-------------------------------------------------------------------------- Test isPositiveInteger------------------------------------------------------------------------functionsuite:testIsPositiveInteger()self:assertTrue(tt.isPositiveInteger(1))self:assertTrue(tt.isPositiveInteger(2))self:assertTrue(tt.isPositiveInteger(2323874623))self:assertFalse(tt.isPositiveInteger(0))self:assertFalse(tt.isPositiveInteger(-1))self:assertFalse(tt.isPositiveInteger(0.5))self:assertFalse(tt.isPositiveInteger(1.5))self:assertFalse(tt.isPositiveInteger('1'))self:assertFalse(tt.isPositiveInteger(math.huge))self:assertFalse(tt.isPositiveInteger('foo'))end-------------------------------------------------------------------------- Test isNan------------------------------------------------------------------------functionsuite:testIsNan()self:assertTrue(tt.isNan(0/0))self:assertTrue(tt.isNan(-(0/0)))self:assertTrue(tt.isNan(math.huge*0))self:assertTrue(tt.isNan(-math.huge*0))self:assertTrue(tt.isNan(-1*math.huge*0))self:assertFalse(tt.isNan(0))self:assertFalse(tt.isNan(1))self:assertFalse(tt.isNan(6))self:assertFalse(tt.isNan(-100))self:assertFalse(tt.isNan(2^0.5))self:assertFalse(tt.isNan(99999999999999999999999999999999999999999999999))self:assertFalse(tt.isNan(math.pi))end-------------------------------------------------------------------------- Test removeDuplicates------------------------------------------------------------------------functionsuite:testRemoveDuplicates()localdupes={1,2,2,3,3,3,4,2,0/0,5,-(0/0),5}-- Dupes removed: {1, 2, 3, 4, NaN, 5, NaN}localremoved=tt.removeDuplicates(dupes)self:assertEquals(7,#removed)self:assertEquals(1,removed[1])self:assertEquals(2,removed[2])self:assertEquals(3,removed[3])self:assertEquals(4,removed[4])self:assertTrue(suite.isNan(removed[5]))self:assertEquals(5,removed[6])self:assertTrue(suite.isNan(removed[7]))self:assertTypeErrorEquals(1,'removeDuplicates','table','number',tt.removeDuplicates,4)self:assertTypeErrorEquals(1,'removeDuplicates','table','nil',tt.removeDuplicates)end-------------------------------------------------------------------------- Sparse array variables------------------------------------------------------------------------localsparseArray={1,nil,2,nil,3,nil,[math.huge]=math.huge,foo='bar',[1.5]=1.5,['4']='four_string'}localsparseArrayConcatenated='123'localnumKeysConcatenated='135'localreverseSparseArrayConcatenated='321'localreverseNumKeysConcatenated='531'-------------------------------------------------------------------------- Test numKeys------------------------------------------------------------------------functionsuite:testnumKeys()localnumKeys=tt.numKeys(sparseArray)self:assertEquals(numKeysConcatenated,suite.concatIpairs(numKeys))self:assertTypeErrorEquals(1,'numKeys','table','number',tt.numKeys,4)self:assertTypeErrorEquals(1,'numKeys','table','nil',tt.numKeys)end-------------------------------------------------------------------------- Test affixNums------------------------------------------------------------------------localaffixArray={1,a0='a0',a001='a001',a1='a1',b2='b2',a3='a3',c4d='c4d',b5='b5',B6='B6',f7='f7',c8d='c8d',a9=nil,a10='a10',[11]=11,['e-f12']='e-f12'}localaNumsConcatenated='1310'localaValsConcatenated='a1a3a10'localbNumsConcatenated='25'localbValsConcatenated='b2b5'localcdNumsConcatenated='48'localcdValsConcatenated='c4dc8d'localefNumsConcatenated='12'localefValsConcatenated='e-f12'functionsuite.concatAffixVals(t,nums,prefix,suffix)localret=''fori,numinipairs(nums)dolocalkey=(prefixor'')..tostring(num)..(suffixor'')ret=ret..tostring(t[key])endreturnretendfunctionsuite:testaffixNums()localaNums=tt.affixNums(affixArray,'a')localbNums=tt.affixNums(affixArray,'b')localcdNums=tt.affixNums(affixArray,'c','d')localefNums=tt.affixNums(affixArray,'e-f')-- "-" is magic, so we need to escape it.self:assertEquals(aNumsConcatenated,suite.concatIpairs(aNums))self:assertEquals(aValsConcatenated,suite.concatAffixVals(affixArray,aNums,'a'))self:assertEquals(bNumsConcatenated,suite.concatIpairs(bNums))self:assertEquals(bValsConcatenated,suite.concatAffixVals(affixArray,bNums,'b'))self:assertEquals(cdNumsConcatenated,suite.concatIpairs(cdNums))self:assertEquals(cdValsConcatenated,suite.concatAffixVals(affixArray,cdNums,'c','d'))self:assertEquals(efNumsConcatenated,suite.concatIpairs(efNums))self:assertEquals(efValsConcatenated,suite.concatAffixVals(affixArray,efNums,'e-f'))self:assertTypeErrorEquals(1,'affixNums','table','number',tt.affixNums,4)self:assertTypeErrorEquals(1,'affixNums','table','nil',tt.affixNums)end-------------------------------------------------------------------------- Test numData------------------------------------------------------------------------functionsuite:testNumData()localt={1,2,[5]=5,foo="foo",foo1="foo1",bar1="bar1",foo6="foo6",bar6="bar6"}localuncompressed=tt.numData(t)localcompressed=tt.numData(t,true)-- Test uncompressed.self:assertEquals(1,uncompressed[1][1])self:assertEquals(2,uncompressed[2][1])self:assertEquals(5,uncompressed[5][1])self:assertEquals("foo",uncompressed.other.foo)self:assertEquals("foo1",uncompressed[1].foo)self:assertEquals("bar1",uncompressed[1].bar)self:assertEquals("foo6",uncompressed[6].foo)self:assertEquals("bar6",uncompressed[6].bar)self:assertEquals(nil,uncompressed[4])-- Test compressed.self:assertEquals(1,compressed[1][1])self:assertEquals(2,compressed[2][1])self:assertEquals(5,compressed[3][1])self:assertEquals("foo",compressed.other.foo)self:assertEquals("foo1",compressed[1].foo)self:assertEquals("bar1",compressed[1].bar)self:assertEquals("foo6",compressed[4].foo)self:assertEquals("bar6",compressed[4].bar)self:assertEquals(nil,compressed[5])end-------------------------------------------------------------------------- Test sparse array functions------------------------------------------------------------------------functionsuite:testCompressSparseArray()localcompressedArray=tt.compressSparseArray(sparseArray)self:assertEquals(sparseArrayConcatenated,suite.concatIpairs(compressedArray))self:assertTypeErrorEquals(1,'compressSparseArray','table','number',tt.compressSparseArray,4)self:assertTypeErrorEquals(1,'compressSparseArray','table','nil',tt.compressSparseArray)endfunctionsuite:testSparseIpairs()localarrayText=''fori,vintt.sparseIpairs(sparseArray)doarrayText=arrayText..tostring(v)endself:assertEquals(sparseArrayConcatenated,arrayText)self:assertTypeErrorEquals(1,'sparseIpairs','table','number',tt.sparseIpairs,4)self:assertTypeErrorEquals(1,'sparseIpairs','table','nil',tt.sparseIpairs)end-------------------------------------------------------------------------- Test size function------------------------------------------------------------------------functionsuite:testSize()self:assertEquals(0,tt.size{})self:assertEquals(3,tt.size{foo='foo',bar='bar',baz='baz'})self:assertEquals(1,tt.size{1})self:assertEquals(5,tt.size{foo='foo',bar='bar',baz='baz',1,2})self:assertTypeErrorEquals(1,'size','table','number',tt.size,4)self:assertTypeErrorEquals(1,'size','table','nil',tt.size)end-------------------------------------------------------------------------- Test binaryLength function------------------------------------------------------------------------functionsuite:testLengthOfEmptyTableIsZero()self:assertEquals(0,tt.length{})endfunctionsuite:testLengthOfArray()localdata={"a","b","c","d","e","f"}self:assertEquals(6,tt.length(data))localmeta=setmetatable({},{__index=data})self:assertEquals(6,tt.length(meta))endfunctionsuite:testLengthOfQuasiArrayWithPrefixes()localdata={key1="value1",key2="value2",key3="value3"}self:assertEquals(3,tt.length(data,"key"))localmeta=setmetatable({},{__index=data})self:assertEquals(3,tt.length(meta,"key"))endfunctionsuite:testLengthChecksForTypeErrors()self:assertTypeErrorEquals(1,'length','table','number',tt.length,1)self:assertTypeErrorEquals(2,'length','string','number',tt.length,{},2)endfunctionsuite:testInArray()self:assertTrue(tt.inArray({"a","b","c","d"},"b"))self:assertTrue(tt.inArray({"a","b","c","d"},"b",0))self:assertTrue(tt.inArray({"a","b","c","d"},"b",1))self:assertTrue(tt.inArray({"a","b","c","d"},"b",2))self:assertTrue(tt.inArray({"a","b","c","d"},"b",-3))self:assertTrue(tt.inArray({"a","b","c","d"},"b",-5))self:assertTrue(tt.inArray({[1]="a",[100]="b",[101]="c"},"b"))self:assertTrue(tt.inArray({[1]="a",[2]="b",[3]="c"},"b",0))self:assertTrue(tt.inArray({first="a",second="b",third="c"},"b"))self:assertFalse(tt.inArray({"a","b","c","d"}))-- value missingself:assertFalse(tt.inArray({"a","b","c","d"},"e"))-- "e" is not in arrayself:assertFalse(tt.inArray({"a","b","c","d"},"b",3))-- "b" is before position 3self:assertFalse(tt.inArray({"a","b","c","d"},"b",5))-- 5 is larger than #arrayself:assertFalse(tt.inArray({"a","b","c","d"},"b",-2))-- "b" is not in the last two positionsself:assertFalse(tt.inArray({[1]="a",[100]="b",[101]="c"},"b",0))-- key 100 is non-consecutiveself:assertFalse(tt.inArray({first="a",second="b",third="c"},"b",0))-- key "second" is not an integerendfunctionsuite:testMerge()self:assertDeepEquals({},tt.merge())localfunctionf()return"foo"endself:assertDeepEquals({"a",1,2,f,3},tt.merge({"a",1,2,f,3}))self:assertDeepEquals({0.1,f,2,"3",{foo="bar"}},tt.merge({0.1,f},{[0.0]=f,2,"3",[1.0]="y"},{{foo="bar"},f=f}))localfunctionfn()tt.merge(2,3)endself:assertThrows(fn,"bad argument #1 to 'merge' (table expected, got number)")endfunctionsuite:testExtend()localt={Z=1,{"Z"}}tt.extend(t,{[0.1]="k",-1})self:assertDeepEquals({{"Z"},Z=1,-1},t)localfunctionfn()tt.extend(t,"banana")endself:assertThrows(fn,"bad argument #2 to 'extend' (table expected, got string)")localfunctionfn()tt.extend(fn,t)endself:assertThrows(fn,"bad argument #1 to 'extend' (table expected, got function)")endreturnsuite
