Module:TableTools/testcases

 -- Unit tests for [[Module:TableTools]]. Click talk page to run tests.

 localScribuntoUnit=require('Module:ScribuntoUnit')
 localsuite=ScribuntoUnit:new()
 locallibName='TableTools'


 -- Helper to run all tests using sandbox version of the library from the debug console. To run against main lib, use =p.run()
 functionsuite.runSandbox()
 localframe=mw.getCurrentFrame():newChild{title='testcases',args={module=libName..'/sandbox',displayMode='log'}}
 returnsuite.run(frame)
 end

 -- Allow test runner to use the sandbox and the primary versions of the library with the same testcases
 functionsuite:module()
 returnrequire('Module:'..(self.frameandself.frame.args.moduleorlibName))
 end

 --[[
  Library-specific tests
 ]]

 ------------------------------------------------------------------------
 -- Helper functions
 ------------------------------------------------------------------------

 functionsuite.concatIpairs(t)
 localret=''
 fori,vinipairs(t)do
 ret=ret..tostring(v)
 end
 returnret
 end

 functionsuite:assertErrorEquals(expected,func,...)
 localsuccess,msg=pcall(func,...)
 self:assertEquals(expected,msg)
 end

 functionsuite: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()
 localtt=self:module()
 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()
 localtt=self:module()
 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()
 localtt=self:module()
 localisNan=tt.isNan
 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(isNan(removed[5]))
 self:assertEquals(5,removed[6])
 self:assertTrue(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'

 ------------------------------------------------------------------------
 -- Test numKeys
 ------------------------------------------------------------------------

 functionsuite:testnumKeys()
 localtt=self:module()
 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)do
 localkey=(prefixor'')..tostring(num)..(suffixor'')
 ret=ret..tostring(t[key])
 end
 returnret
 end

 functionsuite:testaffixNums()
 localtt=self:module()
 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()
 localtt=self:module()
 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()
 localtt=self:module()
 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)
 end

 functionsuite:testSparseIpairs()
 localtt=self:module()
 localarrayText=''
 fori,vintt.sparseIpairs(sparseArray)do
 arrayText=arrayText..tostring(v)
 end
 self: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()
 localtt=self:module()
 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

 returnsuite