Module:Math/testcases

-- 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.getLuaResult(funcName, args)
	args = args or {}
	return mm['_' .. funcName](unpack(args))
end

function suite:assertLuaEquals(expected, funcName, args)
	args = args or {}
	self:assertEquals(expected, self.getLuaResult(funcName, args))
end

function 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 .. '}}'
end

function suite:getInvokeResult(funcName, args)
	args = args or {}
	local invocation = self.buildInvocation(funcName, args)
	local result = self.frame:preprocess(invocation)
	if tonumber(result) then
		return tonumber(result)
	else
		return result
	end
end

function suite:assertInvokeEquals(expected, funcName, args)
	args = args or {}
	local invokeResult = self:getInvokeResult(funcName, args)
	self:assertEquals(expected, invokeResult)
end

function suite:assertLuaAndInvokeTrue(trueFunc, funcName, args)
	args = args or {}
	local invokeResult = self:getInvokeResult(funcName, args)
	local luaResult = self.getLuaResult(funcName, args)
	self:assertTrue(trueFunc(invokeResult))
	self:assertTrue(trueFunc(luaResult))
end

function suite:assertLuaAndInvokeEqual(funcName, testTable)
	local expected = testTable[1]
	local args = testTable[2] or {}
	self:assertLuaEquals(expected, funcName, args)
	self:assertInvokeEquals(expected, funcName, args)
end

function suite:assertLuaAndInvokeEqualMany(funcName, testTables)
	for i, testTable in ipairs(testTables) do
		self:assertLuaAndInvokeEqual(funcName, testTable)
	end
end

-------------------------------------------------------------------------------
-- Test random
-------------------------------------------------------------------------------

function suite:test_random()
	suite:assertLuaAndInvokeTrue(function (n) return n >= 0 and n < 1 end, 'random')
	suite:assertLuaAndInvokeTrue(function (n) return n == 1 or n == 2 end, 'random', {2})
	suite:assertLuaAndInvokeTrue(function (n) return n >= 1 and n <= 10 and math.floor(n) == n end, 'random', {10})
	suite: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'},
	}
	resultEqualsMany(self, 'max', tests)
end
 
-------------------------------------------------------------------------------
-- Test average
-------------------------------------------------------------------------------

function suite:test_average()
	local tests = {
		{'6', '5|6|7'},
		{'-7', '-7'},
		{'10000000002', '10000000001|10000000002|10000000003'},
	}
	resultEqualsMany(self, 'average', tests)
end
 
-------------------------------------------------------------------------------
-- Test min
-------------------------------------------------------------------------------

function suite:test_min()
	local tests = {
		{'', ''},
		{'1', '1|2|3'},
		{'-3', '-1|-2|-3'},
    }
	resultEqualsMany(self, 'min', tests)
end
 
-------------------------------------------------------------------------------
-- Test order
-------------------------------------------------------------------------------

function suite:test_order()
	local tests = {
		{'0', '2'},
		{'1', '20'},
		{'2', '200'},
		{'0', 'x = 5'},
		{'<strong class="error">Formatting error: order of magnitude input appears non-numeric</strong>', 'string'},
	}
	resultEqualsMany(self, 'order', tests)
end
 
-------------------------------------------------------------------------------
-- Test precision
-------------------------------------------------------------------------------

function suite:test_precison()
	local tests = {
		{'4', '1.9856'},
		{'1', '1.1'},
		{'10', '1.9999999999'},
		{'4', 'x = 1.9888'},
		{'<strong class="error">Formatting error: precision input appears non-numeric</strong>', 'letra'},
	}
	resultEqualsMany(self, 'precision', tests)
end
 
-------------------------------------------------------------------------------
-- Test round
-------------------------------------------------------------------------------

function suite:test_round()
	local tests = {
		{'2', '1.99999'},
		{'2', '1.99999|0'},
		{'1.9', '1.94|1'},
		{'20', '15|-1'},
		{'3', 'value = 2.99999|precision = 2'},
	}
	resultEqualsMany(self, 'round', tests)
end
 
-------------------------------------------------------------------------------
-- Test precision format
-------------------------------------------------------------------------------

function suite:test_precison_format()
	local tests = {
		{'10.00', '10|2'}
	}
	resultEqualsMany(self, 'precision_format', tests)
end

--]==]

return suite