Module:TableTools/testcases

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

local tt = require('Module:TableTools') -- the module to be tested
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()

------------------------------------------------------------------------
-- Sparse array variables
------------------------------------------------------------------------

local sparseArray = {1, nil, 2, nil, 3, nil, [math.huge] = math.huge, foo = 'bar', [1.5] = 1.5, ['4'] = 'four_string'}
local sparseArrayConcatenated = '123'
local numKeysConcatenated = '135'

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

function suite.concatIpairs(t)
	local ret = ''
	for i, v in ipairs(t) do
		ret = ret .. tostring(v)
	end
	return ret
end

function suite.tablesAreEqual(t1, t2)
	-- Returns true if two tables are equal and false if not.
	for k, v in pairs(t1) do
		if v ~= t2[k] then
			return false
		end
	end
	for k, v in pairs(t2) do
		if v ~= t1[k] then
			return false
		end
	end
	return true
end

------------------------------------------------------------------------
-- Test isPositiveInteger
------------------------------------------------------------------------

function suite: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

------------------------------------------------------------------------
-- Union and intersection variables
------------------------------------------------------------------------

local nums1 = {1, 3, 4, 5, foo = 7}
local nums2 = {2, bar = 3, 5, 6}
local nums3 = {2, 3, 5, 8}
local numsUnionConcatenated = '12345678'
local numsIntersectionConcatenated = '35'

local strings1 = {'foo', 'bar', 'baz'}
local strings2 = {'eggs', 'sausage', 'spam', 'bar', 'baz'}
local stringsUnionConcatenated = 'barbazeggsfoosausagespam'
local stringsIntersectionConcatenated = 'barbaz'

local mixed1 = {1, 3, 4, 5, foo = 7, 'foo', 'bar', 'baz'}
local mixed2 = {2, bar = 3, 5, 6, 'eggs', 'sausage', 'spam', 'bar', 'baz'}

------------------------------------------------------------------------
-- Test getUnion
------------------------------------------------------------------------

function suite:testGetUnion()
	local numsUnion = tt.getUnion(nums1, nums2, nums3)
	self:assertEquals(numsUnionConcatenated, suite.concatIpairs(numsUnion))
end

------------------------------------------------------------------------
-- Test getIntersection
------------------------------------------------------------------------

function suite:testGetIntersection()
	local numsIntersection = tt.getIntersection(nums1, nums2, nums3)
	self:assertEquals(numsIntersectionConcatenated, suite.concatIpairs(numsIntersection))
end

------------------------------------------------------------------------
-- Test getNumKeys
------------------------------------------------------------------------

function suite:testGetNumKeys()
	local numKeys = tt.getNumKeys(sparseArray)
    self:assertEquals(numKeysConcatenated, suite.concatIpairs(numKeys))
end

------------------------------------------------------------------------
-- Test getAffixNums
------------------------------------------------------------------------

local affixArray = {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}
local aNumsConcatenated = '1310'
local aValsConcatenated = 'a1a3a10'
local bNumsConcatenated = '25'
local bValsConcatenated = 'b2b5'
local cdNumsConcatenated = '48'
local cdValsConcatenated = 'c4dc8d'

function suite.concatAffixVals(t, nums, prefix, suffix)
	local ret = ''
	for i, num in ipairs(nums) do
		local key = (prefix or '') .. tostring(num) .. (suffix or '')
		ret = ret .. tostring(t[key])
	end
	return ret
end

function suite:testGetAffixNums()
	local aNums = tt.getAffixNums(affixArray, 'a')
	local bNums = tt.getAffixNums(affixArray, 'b')
	local cdNums = tt.getAffixNums(affixArray, 'c', 'd')
    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'))
end

------------------------------------------------------------------------
-- Test sparse array functions
------------------------------------------------------------------------

function suite:testCompressSparseArray()
	local compressedArray = tt.compressSparseArray(sparseArray)
    self:assertEquals(sparseArrayConcatenated, suite.concatIpairs(compressedArray))
end

function suite:testSparseIpairs()
	local arrayText = ''
	for i, v in tt.sparseIpairs(sparseArray) do
		arrayText = arrayText .. tostring(v)
	end
	self:assertEquals(sparseArrayConcatenated, arrayText)
end

return suite