Difference between revisions of "Module:Math/testcases"

From blackwiki
Jump to navigation Jump to search
blackwiki>Mr. Stradivarius
(save progress writing the helper functions)
blackwiki>Mr. Stradivarius
(get random function tests working)
Line 11: Line 11:
  
 
function suite.getLuaResult(funcName, args)
 
function suite.getLuaResult(funcName, args)
return mm[funcName](unpack(args))
+
args = args or {}
 +
return mm['_' .. funcName](unpack(args))
 
end
 
end
  
 
function suite:assertLuaEquals(expected, funcName, args)
 
function suite:assertLuaEquals(expected, funcName, args)
 +
args = args or {}
 
self:assertEquals(expected, self.getLuaResult(funcName, args))
 
self:assertEquals(expected, self.getLuaResult(funcName, args))
 
end
 
end
  
 
function suite.buildInvocation(funcName, args)
 
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]].
 
-- Build a module invocation equivalent to the args table. Taken from [[Module:Unsubst]].
 
-- Numbered args first.
 
-- Numbered args first.
 
local ret = '{{#invoke:' .. moduleName .. '|' .. funcName
 
local ret = '{{#invoke:' .. moduleName .. '|' .. funcName
for k, v in ipairs(args) do
+
for k, v in ipairs(argsClone) do
 +
v = tostring(v)
 
if string.find(v, '=', 1, true) then
 
if string.find(v, '=', 1, true) then
 
-- likely something like 1=foo=bar, we need to do it as a named arg
 
-- likely something like 1=foo=bar, we need to do it as a named arg
Line 28: Line 33:
 
end
 
end
 
ret = ret .. '|' .. v
 
ret = ret .. '|' .. v
args[k] = nil
+
argsClone[k] = nil
 
end
 
end
for k, v in pairs(args) do
+
for k, v in pairs(argsClone) do
 +
k = tostring(k)
 +
v = tostring(v)
 
ret = ret .. '|' .. k .. '=' .. v
 
ret = ret .. '|' .. k .. '=' .. v
 
end
 
end
Line 37: Line 44:
  
 
function suite:getInvokeResult(funcName, args)
 
function suite:getInvokeResult(funcName, args)
 +
args = args or {}
 
local invocation = self.buildInvocation(funcName, args)
 
local invocation = self.buildInvocation(funcName, args)
return self.frame:preprocess(invocation)
+
local result = self.frame:preprocess(invocation)
 +
if tonumber(result) then
 +
return tonumber(result)
 +
else
 +
return result
 +
end
 
end
 
end
  
 
function suite:assertInvokeEquals(expected, funcName, args)
 
function suite:assertInvokeEquals(expected, funcName, args)
 +
args = args or {}
 
local invokeResult = self:getInvokeResult(funcName, args)
 
local invokeResult = self:getInvokeResult(funcName, args)
 
self:assertEquals(expected, invokeResult)
 
self:assertEquals(expected, invokeResult)
Line 47: Line 61:
  
 
function suite:assertLuaAndInvokeTrue(trueFunc, funcName, args)
 
function suite:assertLuaAndInvokeTrue(trueFunc, funcName, args)
 +
args = args or {}
 
local invokeResult = self:getInvokeResult(funcName, args)
 
local invokeResult = self:getInvokeResult(funcName, args)
 
local luaResult = self.getLuaResult(funcName, args)
 
local luaResult = self.getLuaResult(funcName, args)
Line 55: Line 70:
 
function suite:assertLuaAndInvokeEqual(funcName, testTable)
 
function suite:assertLuaAndInvokeEqual(funcName, testTable)
 
local expected = testTable[1]
 
local expected = testTable[1]
local args = testTable[2]
+
local args = testTable[2] or {}
 
self:assertLuaEquals(expected, funcName, args)
 
self:assertLuaEquals(expected, funcName, args)
 
self:assertInvokeEquals(expected, funcName, args)
 
self:assertInvokeEquals(expected, funcName, args)
Line 71: Line 86:
  
 
function suite:test_random()
 
function suite:test_random()
local rand0 = tonumber(invokeMath('random'))
+
suite:assertLuaAndInvokeTrue(function (n) return n >= 0 and n < 1 end, 'random')
local rand2 = tonumber(invokeMath('random', '2'))
+
suite:assertLuaAndInvokeTrue(function (n) return n == 1 or n == 2 end, 'random', {2})
local rand10 = tonumber(invokeMath('random', '10'))
+
suite:assertLuaAndInvokeTrue(function (n) return n >= 1 and n <= 10 and math.floor(n) == n end, 'random', {10})
local rand10_20 = tonumber(invokeMath('random', '10|20'))
+
suite:assertLuaAndInvokeTrue(function (n) return n >= 10 and n <= 20 and math.floor(n) == n end, 'random', {10, 20})
suite:assertTrue(rand0 >= 0 and rand0 < 1)
 
suite:assertTrue(rand2 == 1 or rand2 == 2)
 
suite:assertTrue(rand10 >= 1 and rand10 <= 10 and math.floor(rand10) == rand10)
 
mw.log(rand10_20)
 
suite:assertTrue(rand10_20 >= 10 and rand10_20 <= 20 and math.floor(rand10_20) == rand10_20)
 
 
end
 
end
 +
 +
--[==[
  
 
-------------------------------------------------------------------------------
 
-------------------------------------------------------------------------------
Line 176: Line 188:
 
resultEqualsMany(self, 'precision_format', tests)
 
resultEqualsMany(self, 'precision_format', tests)
 
end
 
end
 +
 +
--]==]
  
 
return suite
 
return suite

Revision as of 12:39, 10 December 2013

Documentation for this module may be created at Module:Math/testcases/doc

-- 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