Modul:UnitTests

Dokumentacija modula

UnitTests provides a unit test facility that can be used by other scripts using require. See Wikipedia:Lua#Unit testing for details. The following is a sample from Module:Zgled/testniprimeri:

-- Unit tests for [[Module:Zgled]]. Click talk page to run tests.
local p = require('Module:UnitTests')

function p:test_hello()
	self:preprocess_equals('{{#invoke:Zgled | hello}}', 'Hello World!')
end

return p

The talk page Module talk:Zgled/testniprimeri executes it with {{#invoke: Zgled/testniprimeri | run_tests}}. Test methods like test_hello above must begin with "test".

Methods

run_tests

• run_tests: Runs all tests. Normally used on talk page of unit tests.

  {{#invoke:Zgled/testniprimeri|run_tests}}
  

• If differs_at is specified, a column will be added showing the first character position where the expected and actual results differ.

  {{#invoke:Zgled/testniprimeri|run_tests|differs_at=1}}
  

• If highlight is specified, failed tests will be highlighted to make them easier to spot. A user script that moves failed tests to the top is also available.

  {{#invoke:Zgled/testniprimeri|run_tests|highlight=1}}
  

• If live_sandbox is specified, the header will show the columns "Test", "Live", "Sandbox", "Expected". This is required when using the preprocess_equals_sandbox_many method.

  {{#invoke:Zgled/testniprimeri|run_tests|live_sandbox=1}}
  

preprocess_equals

• preprocess_equals(text, expected, options): Gives a piece of wikitext to preprocess and an expected resulting value. Scripts and templates can be invoked in the same manner they would be in a page.

  self:preprocess_equals('{{#invoke:Zgled | hello}}', 'Hello, world!', {nowiki=1})
  

preprocess_equals_many

• preprocess_equals_many(prefix, suffix, cases, options): Performs a series of preprocess_equals() calls on a set of given pairs. Automatically adds the given prefix and suffix to each text.

  self:preprocess_equals_many('{{#invoke:Zgled | hello_to |', '}}', {
  	{'John', 'Hello, John!'},
  	{'Jane', 'Hello, Jane!'},
  }, {nowiki=1})
  

preprocess_equals_preprocess

• preprocess_equals_preprocess(text, expected, options): Gives two pieces of wikitext to preprocess and determines if they produce the same value. Useful for comparing scripts to existing templates.

  self:preprocess_equals_preprocess('{{#invoke:Zgled | hello}}', '{{Hello}}', {nowiki=1})
  

preprocess_equals_preprocess_many

• preprocess_equals_preprocess_many(prefix1, suffix1, prefix2, suffix2, cases, options): Performs a series of preprocess_equals_preprocess() calls on a set of given pairs. The prefix/suffix supplied for both arguments is added automatically. If in any case the second part is not specified, the first part will be used.

  self:preprocess_equals_preprocess_many('{{#invoke:ConvertNumeric | numeral_to_english|', '}}', '{{spellnum', '}}', {
  	{'2'}, -- equivalent to {'2','2'},
  	{'-2', '-2.0'},
  }, {nowiki=1})
  

preproccess_equals_compare

• preproccess_equals_compare(live, sandbox, expected, options)

Performs a single comparison between the output of specified modules (live and sandbox - these do not have to be the actual live and sandbox versions of the same module), and vs an expected result. Live and sandbox must each be specified as the full call to the module, with called function and parameters. Ensure live_sandbox=1 is specified in the call to run_tests() or there may be some errors in the output.

self:preproccess_equals_compare('{{#invoke:Zgled|hello_to|Jane}}',
'{{#invoke:Sandbox/ExampleUser/Example|hello_to|Jane}}',
'Hello, Jane!',
{nowiki=1})

preprocess_equals_sandbox_many

• preprocess_equals_sandbox_many(module, function, cases, options): Performs a series of preprocess_equals_compare() calls on a set of given pairs. The test compares the live version of the module vs the /sandbox version and vs an expected result. Ensure live_sandbox=1 is specified in the call to run_tests() or there may be some errors in the output.

  self:preprocess_equals_sandbox_many('{{#invoke:Zgled', 'hello_to', {
  	{'John', 'Hello, John!'},
  	{'Jane', 'Hello, Jane!'},
  }, {nowiki=1})
  

equals

• equals(name, actual, expected, options): Gives a computed value and the expected value, and checks if they are equal according to the == operator. Useful for testing modules that are designed to be used by other modules rather than using #invoke.

  self:equals('Simple addition', 2 + 2, 4, {nowiki=1})
  

equals_deep

• equals_deep(name, actual, expected, options): Like equals, but handles tables by doing a deep comparison. Neither value should contain circular references, as they are not handled by the current implementation and may result in an infinite loop.

  self:equals_deep('Table comparison', createRange(1,3), {1,2,3}, {nowiki=1})
  

Test options

These are the valid options that can be passed into the options parameters of the test functions listed above.

nowiki

Enabling this wraps the output text in <nowiki>...</nowiki> tags to avoid the text being rendered (e.g. <span>[[Example|Page]]</span> instead of Page)

combined

Only available in preprocess_equals, preprocess_equals_preprocess, preproccess_equals_compare and preprocess_equals_sandbox_many

Enabling this will display the output text in both the rendered mode and the nowiki mode to allow for both a raw text and visual comparison.

noexpectation

Only available in preprocess_equals and preprocess_equals_preprocess

Enabling this and providing an empty string as an expected value makes a test always succeed, regardless of the actual value.

templatestyles

Only available in preprocess_equals, preprocess_equals_preprocess and preprocess_equals_sandbox_many

Enabling this fixes the IDs in the strip markers ...</templatestyles> produces when processed to avoid incorrectly failing the tests.

stripmarker

Only available in preprocess_equals, preprocess_equals_preprocess, preproccess_equals_compare and preprocess_equals_sandbox_many

Enabling this fixes the IDs in all strip markers produces when processed to avoid incorrectly failing the tests.

display

Only available in equals

An optional function that changes how the output from the tests are displayed. This doesn't affect the comparison process.

See also

• Module:ScribuntoUnit – alternative unit test module

-- UnitTester provides unit testing for other Lua scripts. For details see [[Wikipedija:Lua#Testiranje enot]].
-- For user documentation see above.
local UnitTester = {}

-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
local cfg = mw.loadData('Module:UnitTests/config')

local frame, tick, cross, should_highlight

local result_table = {n = 0}
local result_table_mt = {
	insert = function (self, ...)
		local n = self.n
		for i = 1, select('#', ...) do
			local val = select(i, ...)
			if val ~= nil then
				n = n + 1
				self[n] = val
			end
		end
		self.n = n
	end,
	insert_format = function (self, ...)
		self:insert(string.format(...))
	end,
	concat = table.concat
}
result_table_mt.__index = result_table_mt
setmetatable(result_table, result_table_mt)

local num_failures_sandbox = 0
local num_failures = 0
local num_runs = 0

local function first_difference(s1, s2)
	s1, s2 = tostring(s1), tostring(s2)
	if s1 == s2 then return '' end
	local max = math.min(#s1, #s2)
	for i = 1, max do
		if s1:sub(i, i) ~= s2:sub(i, i) then return i end
	end
	return max + 1
end

local function add_diff_highlighting(str)
	if mw.ustring.find(str, "%s") then
		return '<span style="background-color: var(--wikt-palette-red-4, pink);">' ..
			string.gsub(str, " ", "&nbsp;") .. '</span>'
	else
		return '<span style="color: var(--wikt-palette-red-9, red);">' ..
			str .. '</span>'
	end
end

local is_combining = require("Module:Unicode data").is_combining


local function find_noncombining(str, i, incr)
	while true do
		local ch = mw.ustring.sub(str, i, i)
		if ch == "" or not is_combining(mw.ustring.byte(ch)) then
			return i
		end
		i = i + incr
	end
end

-- Highlight character where a difference was found. Start highlight at first
-- non-combining character before the position. End it after the first non-
-- combining characters after the position.
local function highlight_difference(actual, expected, differs_at)
	if type(differs_at) ~= "number" or not (actual and expected) then
		return actual
	end
	differs_at = find_noncombining(expected, differs_at, -1)
	local i = find_noncombining(actual, differs_at, -1)
	local j = find_noncombining(actual, differs_at + 1, 1)
	j = j - 1
	return mw.ustring.sub(actual, 1, i - 1) ..
		add_diff_highlighting(mw.ustring.sub(actual, i, j)) ..
		mw.ustring.sub(actual, j + 1, -1)
end

local function return_varargs(...)
	return ...
end

function UnitTester:calculate_output(text, expected, actual, options)
	-- Set up some variables for throughout for ease
	num_runs = num_runs + 1
	options = options or {}

	-- Fix any stripmarkers if asked to do so to prevent incorrect fails
	local compared_expected = expected
	local compared_actual = actual
	if options.templatestyles then
		local pattern = '(\127[^\127]*UNIQ%-%-templatestyles%-)(%x+)(%-QINU[^\127]*\127)'
		local _, expected_stripmarker_id = compared_expected:match(pattern)				-- when module rendering has templatestyles strip markers, use ID from expected to prevent false test fail
		if expected_stripmarker_id then
			compared_actual = compared_actual:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')	-- replace actual id with expected id; ignore second capture in pattern
			compared_expected = compared_expected:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')		-- account for other strip markers
		end
	end
	if options.stripmarker then
		local pattern = '(\127[^\127]*UNIQ%-%-%l+%-)(%x+)(%-%-?QINU[^\127]*\127)'
		local _, expected_stripmarker_id = compared_expected:match(pattern)
		if expected_stripmarker_id then
			compared_actual = compared_actual:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
			compared_expected = compared_expected:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
		end
	end

	-- Perform the comparison
	local success = compared_actual == compared_expected
	if options.noexpectation and compared_expected == '' then
		success = true
	end
	if not success then
		num_failures = num_failures + 1
	end

	-- Sort the wikitext for displaying the results
	if options.combined then
		-- We need 2 rows available for the expected and actual columns
		-- Top one is parsed, bottom is unparsed
		local diff, differs_at = 0, self.differs_at and (' \n| rowspan=2|' .. first_difference(compared_expected, compared_actual)) or ''
		-- Local copies of tick/cross to allow for highlighting
		local highlight = (should_highlight and not success and 'style="background: #fc0;" ') or ''
		local highlight_diff = return_varargs
		if self.differs_at then
			diff = first_difference(compared_expected, compared_actual)
			differs_at = ' \n| rowspan=2|' .. diff
			if type(diff) == "number" then
				highlight_diff = highlight_difference
			end
		end
		result_table:insert(													-- Start output
			'| ', highlight, 'rowspan=2|', success and tick or cross,			-- Tick/Cross (2 rows)
			' \n| rowspan=2|', mw.text.nowiki(text), ' \n| ',					-- Text used for the test (2 rows)
			expected, ' \n| ', highlight_diff(actual, expected, diff),											-- The parsed outputs (in the 1st row)
			differs_at, ' \n|-\n| ',											-- Where any relevant difference was (2 rows)
			mw.text.nowiki(expected), ' \n| ', highlight_diff(mw.text.nowiki(actual), mw.text.nowiki(actual), first_difference(mw.text.nowiki(expected), mw.text.nowiki(actual))),			-- The unparsed outputs (in the 2nd row)
			'\n|-\n'															-- End output
		)
	else
		-- Display normally with whichever option was preferred (nowiki/parsed)
		local differs_at = ''
		local formatting = options.nowiki and mw.text.nowiki or return_varargs
		local highlight = (should_highlight and not success and 'style="background: #fc0;" |') or ''
		local formated_expected, formated_actual = formatting(expected), formatting(actual)
		if self.differs_at then
			local diff = first_difference(compared_expected, compared_actual)
			differs_at = ' \n| ' .. diff
			if type(diff) == "number" then
				formated_actual = highlight_difference(formated_actual, formated_expected, first_difference(formated_actual, formated_expected))
			end
		end
		result_table:insert(													-- Start output
			'| ', highlight, success and tick or cross,							-- Tick/Cross
			' \n| ', mw.text.nowiki(text), ' \n| ',								-- Text used for the test
			formated_expected, ' \n| ', formated_actual,					-- The formatted outputs
			differs_at,															-- Where any relevant difference was
			'\n|-\n'															-- End output
		)
	end
end

function UnitTester:preprocess_equals(text, expected, options)
	local actual = frame:preprocess(text)
	self:calculate_output(text, expected, actual, options)
end

function UnitTester:preprocess_equals_many(prefix, suffix, cases, options)
	for _, case in ipairs(cases) do
		self:preprocess_equals(prefix .. case[1] .. suffix, case[2], options)
	end
end

function UnitTester:preprocess_equals_preprocess(text1, text2, options)
	local actual = frame:preprocess(text1)
	local expected = frame:preprocess(text2)
	self:calculate_output(text1, expected, actual, options)
end

function UnitTester:preprocess_equals_compare(live, sandbox, expected, options)
	options = options or {}
	local live_text = frame:preprocess(live)
	local sandbox_text = frame:preprocess(sandbox)
	local highlight_live = false
	local highlight_sandbox = false
	num_runs = num_runs + 1
	local compared_live = live_text
	local compared_sandbox = sandbox_text
	local compared_expected = expected
	if options.templatestyles then
		local pattern = '(\127[^\127]*UNIQ%-%-templatestyles%-)(%x+)(%-QINU[^\127]*\127)'
		local _, expected_stripmarker_id = compared_expected:match(pattern)				-- when module rendering has templatestyles strip markers, use ID from expected to prevent false test fail
		if expected_stripmarker_id then
			compared_live = compared_live:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')	-- replace actual id with expected id; ignore second capture in pattern
			compared_sandbox = compared_sandbox:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')	-- replace actual id with expected id; ignore second capture in pattern
			compared_expected = compared_expected:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')		-- account for other strip markers
		end
	end
	if options.stripmarker then
		local pattern = '(\127[^\127]*UNIQ%-%-%l+%-)(%x+)(%-%-?QINU[^\127]*\127)'
		local _, expected_stripmarker_id = compared_expected:match(pattern)
		if expected_stripmarker_id then
			compared_live = compared_live:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
			compared_sandbox = compared_sandbox:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
			compared_expected = compared_expected:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
		end
	end
	local success = compared_live == compared_expected and compared_sandbox == compared_expected
	if not success then
		if compared_live ~= compared_expected then
			num_failures = num_failures + 1
			highlight_live = true
		end

		if compared_sandbox ~= compared_expected then
			num_failures_sandbox = num_failures_sandbox + 1
			highlight_sandbox = true
		end
	end

	-- Sort the wikitext for displaying the results
	if options.combined then
		-- We need 2 rows available for the expected, live, and sandbox columns
		-- Top one is parsed, bottom is unparsed
		local differs_at = ''
		local highlight_diff_live, highlight_diff_sandbox = return_varargs, return_varargs
		local diff_live, diff_sandbox = 0,0
		if self.differs_at then
			diff_live = first_difference(compared_expected, compared_live)
			diff_sandbox = first_difference(compared_expected, compared_sandbox)
			differs_at = ' \n| rowspan=2|' .. (diff_live or diff_sandbox)
			if type(diff_live) == "number" then
				highlight_diff_live = highlight_difference
			end
			if type(diff_sandbox) == "number" then
				highlight_diff_sandbox = highlight_difference
			end
		end

		result_table:insert(
			'| ', 'rowspan=2|', not highlight_live and tick or cross, not highlight_sandbox and tick or cross,
			' \n| rowspan=2|', mw.text.nowiki(live),
			should_highlight and highlight_live and ' \n| style="background: #fc0;" | ' or ' \n| ',
			highlight_diff_live(live_text, expected, diff_live),
			should_highlight and highlight_sandbox and ' \n| style="background: #fc0;" | ' or ' \n| ',
			highlight_diff_sandbox(sandbox_text, expected, diff_sandbox),
			' \n| ',
			expected,
			differs_at,
			should_highlight and highlight_sandbox and ' \n|-\n| style="background: #fc0;" | ' or ' \n|-\n| ',
			highlight_diff_live(mw.text.nowiki(live_text), mw.text.nowiki(expected), first_difference(mw.text.nowiki(expected), mw.text.nowiki(live_text))),
			should_highlight and highlight_sandbox and ' \n| style="background: #fc0;" | ' or ' \n| ',
			highlight_diff_sandbox(mw.text.nowiki(sandbox_text), mw.text.nowiki(expected), first_difference(mw.text.nowiki(expected), mw.text.nowiki(sandbox_text))),
			' \n| ',
			mw.text.nowiki(expected),
			'\n|-\n'
		)
	else
		-- Display normally with whichever option was preferred (nowiki/parsed)
		local differs_at = ''
		local formatting = options.nowiki and mw.text.nowiki or return_varargs
		local formated_expected, formated_live, formated_sandbox = formatting(expected), formatting(live_text), formatting(sandbox_text)
		if self.differs_at then
			local diff = first_difference(compared_expected, live_text)
			local diff2 = first_difference(compared_expected, sandbox_text)
			differs_at = ' \n| ' .. (diff or diff2)
			if type(diff) == "number" then
				formated_live = highlight_difference(formated_live, formated_expected, first_difference(formated_live, formated_expected))
			end
			if type(diff2) == "number" then
				formated_sandbox = highlight_difference(formated_sandbox, formated_expected, first_difference(formated_sandbox, formated_expected))
			end
		end
		result_table:insert(
			'| ', not highlight_live and tick or cross, not highlight_sandbox and tick or cross,
			' \n| ',
			mw.text.nowiki(live),
			should_highlight and highlight_live and ' \n| style="background: #fc0;" | ' or ' \n| ',
			formated_live,
			should_highlight and highlight_sandbox and ' \n| style="background: #fc0;" | ' or ' \n| ',
			formated_sandbox,
			' \n| ',
			formated_expected,
			differs_at,
			'\n|-\n'
		)
	end
end

function UnitTester:preprocess_equals_preprocess_many(prefix1, suffix1, prefix2, suffix2, cases, options)
	for _, case in ipairs(cases) do
		self:preprocess_equals_preprocess(prefix1 .. case[1] .. suffix1, prefix2 .. (case[2] and case[2] or case[1]) .. suffix2, options)
	end
end

function UnitTester:preprocess_equals_sandbox_many(module, function_name, cases, options)
	for _, case in ipairs(cases) do
		local live = module .. '|' .. function_name .. '|' .. case[1] .. '}}'
		local sandbox = module .. '/peskovnik|' .. function_name .. '|' .. case[1] .. '}}'
		self:preprocess_equals_compare(live, sandbox, case[2], options)
	end
end

function UnitTester:equals(name, actual, expected, options)
	num_runs = num_runs + 1
	if actual == expected then
		result_table:insert('| ', tick)
	else
		result_table:insert('| ', cross)
		num_failures = num_failures + 1
	end
	local formatting = (options and options.nowiki and mw.text.nowiki) or return_varargs
	local differs_at = self.differs_at and (' \n| ' .. first_difference(expected, actual)) or ''
	local display = options and options.display or return_varargs
	result_table:insert(' \n| ', name, ' \n| ',
		formatting(tostring(display(expected))), ' \n| ',
		formatting(tostring(display(actual))), differs_at, '\n|-\n')
end

local deep_compare; do
	--//pulled from [[wikt:Module:table/deepEquals]]
	local function is_eq(a, b, seen, include_mt)
		-- If `a` and `b` have been compared before, return the memoized result. This will usually be true, since failures normally fail the whole check outright, but match failures are tolerated during the laborious check without this happening, since it compares key/value pairs until it finds a match, so it could be false.
		local memo_a = seen[a]
		if memo_a then
			local result = memo_a[b]
			if result ~= nil then
				return result
			end
			-- To avoid recursive references causing infinite loops, assume the tables currently being compared are equivalent by memoizing the comparison as true; this will be corrected to false if there's a match failure.
			memo_a[b] = true
		else
			memo_a = {[b] = true}
			seen[a] = memo_a
		end
		-- Don't bother checking `memo_b` for `a`, since if `a` and `b` had been compared before then `b` would be in `memo_a`, but it isn't.
		local memo_b = seen[b]
		if memo_b then
			memo_b[a] = true
		else
			memo_b = {[a] = true}
			seen[b] = memo_b
		end
		-- If `include_mt` is set, check the metatables are equivalent.
		if include_mt then
			local mt_a, mt_b = getmetatable(a), getmetatable(b)
			if not (mt_a == mt_b or type(mt_a) == "table" and type(mt_b) == "table" and is_eq(mt_a, mt_b, seen, true)) then
				memo_a[b], memo_b[a] = false, false
				return false
			end
		end
		-- Copy all key/values pairs in `b` to `remaining_b`, and count the size: this uses `pairs`, which will also be used to iterate over `a`, ensuring that `a` and `b` are iterated over using the same iterator. This is necessary to ensure that `deepEquals(a, b)` and `deepEquals(b, a)` always give the same result. Simply iterating over `a` while accessing keys in `b` for comparison would ignore any `__pairs` metamethod that `b` has, which could cause asymmetrical outputs if `__pairs` returns more or less than the complete set of key/value pairs accessible via `__index`, so using `pairs` for both `a` and `b` prevents this.
		-- TODO: handle exotic `__pairs` methods which return the same key multiple times with different values.
		local remaining_b, size_b = {}, 0
		for k_b, v_b in pairs(b) do
			remaining_b[k_b], size_b = v_b, size_b + 1
		end
		-- Fast check: iterate over the keys in `a`, checking if an equivalent value exists at the same key in `remaining_b`. As matches are found, key/value pairs are removed from `remaining_b`. If any keys in `a` or `remaining_b` are tables, the fast check will only work if the exact same object exists as a key in the other table. Any others from `a` that don't match anything in `remaining_b` are added to `remaining_a`, while those in `remaining_b` that weren't found will still remain once the loop ends. `remaining_a` and `remaining_b` are then compared at the end with the laborious check.
		local size_a, remaining_a = 0
		for k, v_a in pairs(a) do
			local v_b = remaining_b[k]
			-- If `k` isn't in `remaining_b`, `a` and `b` can't be equivalent unless it's a table.
			if v_b == nil then
				if type(k) ~= "table" then
					memo_a[b], memo_b[a] = false, false
					return false
				-- Otherwise, add the `k`/`v_a` pair to `remaining_a` for the laborious check.
				elseif not remaining_a then
					remaining_a = {}
				end
				remaining_a[k], size_a = v_a, size_a + 1
			-- Otherwise, if `k` exists in `a` and `remaining_b`, `v_a` and `v_b` must be equivalent for there to be a match.
			elseif v_a == v_b or type(v_a) == "table" and type(v_b) == "table" and is_eq(v_a, v_b, seen, include_mt) then
				remaining_b[k], size_b = nil, size_b - 1
			else
				memo_a[b], memo_b[a] = false, false
				return false
			end
		end
		-- Must be the same number of remaining keys in each table.
		if size_a ~= size_b then
			memo_a[b], memo_b[a] = false, false
			return false
		-- If the size is 0, there's nothing left to check.
		elseif size_a == 0 then
			return true
		end
		-- Laborious check: since it's not possible to use table lookups to check if two keys are equivalent when they're tables, check each key/value pair in `remaining_a` against every key/value pair in `remaining_b` until a match is found, removing the matching key/value pair from `remaining_b` each time, to ensure one-to-one equivalence.
		for k_a, v_a in next, remaining_a do
			local success
			for k_b, v_b in next, remaining_b do
				-- Keys/value pairs must be equivalent in order to match.
				if ( -- More efficient to compare the values first, as they might not be tables.
					(v_a == v_b or type(v_a) == "table" and type(v_b) == "table" and is_eq(v_a, v_b, seen, include_mt)) and
					(k_a == k_b or type(k_a) == "table" and type(k_b) == "table" and is_eq(k_a, k_b, seen, include_mt))
				) then
					-- Remove matched key from `remaining_b`, and break the inner loop.
					success, remaining_b[k_b] = true, nil
					break
				end
			end
			-- Fail if `remaining_b` runs out of keys, as the `k_a`/`v_a` pair still hasn't matched.
			if not success then
				memo_a[b], memo_b[a] = false, false
				return false
			end
		end
		-- If every key/value pair in `remaining_a` matched with one in `remaining_b`, `a` and `b` must be equivalent. Note that `remaining_b` will now be empty, since the laborious check only starts if `remaining_a` and `remaining_b` are the same size.
		return true
	end
	deep_compare = function(a, b, ignore_mt)
		-- Do simple checks before calling is_eq to avoid generating an unnecessary memo.
		-- Simple equality check and type check; if not a ~= b, a and b can only be equivalent if they're both tables.
		return a == b or type(a) == "table" and type(b) == "table" and is_eq(a, b, {}, not ignore_mt)
	end
end

local function val_to_str(obj)
	local function table_key_to_str(k)
		if type(k) == 'string' and mw.ustring.match(k, '^[_%a][_%a%d]*$') then
			return k
		else
			return '[' .. val_to_str(k) .. ']'
		end
	end

	if type(obj) == 'string' then
		obj = mw.ustring.gsub(obj, '\n', '\\n')
		if mw.ustring.match(mw.ustring.gsub(obj, '[^\'"]', ''), '^"+$') then
			return "'" .. obj .. "'"
		end
		return '"' .. mw.ustring.gsub(obj, '"', '\\"' ) .. '"'
	elseif type(obj) == 'table' then
		local result, checked = {}, {}
		for k, v in ipairs(obj) do
			table.insert(result, val_to_str(v))
			checked[k] = true
		end
		for k, v in pairs(obj) do
			if not checked[k] then
				table.insert(result, table_key_to_str(k) .. '=' .. val_to_str(v))
			end
		end
		return '{' .. table.concat(result, ',') .. '}'
	else
		return tostring(obj)
	end
end
local function insert_differences(keys, t1, t2)
	for k, v1 in pairs(t1) do
		local v2 = t2[k]
		if v2 == nil or not deep_compare(v1, v2, true) then
			table.insert(keys, k)
		end
	end
end

local function get_differing_keys(t1, t2)
	local ty1 = type(t1)
	if not (ty1 == type(t2) and ty1 == "table") then
		return nil
	end

	local keys = {}
	insert_differences(keys, t1, t2)
	insert_differences(keys, t2, t1)

	return keys
end

local function extract_keys(t, keys)
	if not keys then
		return t
	end
	local new_t = {}
	for _, key in ipairs(keys) do
		new_t[key] = t[key]
	end
	return new_t
end

function UnitTester:equals_deep(name, actual, expected, options)
	num_runs = num_runs + 1
	local actual_str, expected_str
	local success = deep_compare(actual, expected, true)
	if success then
		result_table:insert('| ', tick)
		if options and options.show_table_difference then
			actual_str = ''
			expected_str = ''
		end
	else
		if options and options.show_table_difference then
			local keys = get_differing_keys(actual, expected)
			actual_str = val_to_str(extract_keys(actual, keys))
			expected_str = val_to_str(extract_keys(expected, keys))
		end
	end
	if (not options) or not options.show_table_difference then
		actual_str = val_to_str(actual)
		expected_str = val_to_str(expected)
	end
	local formatting = (options and options.nowiki and mw.text.nowiki) or return_varargs
	local differs_at = self.differs_at and (' \n| ' .. first_difference(expected_str, actual_str)) or ''
	result_table:insert(' \n| ', name, ' \n| ', formatting(expected_str),
		' \n| ', formatting(actual_str), differs_at, '\n|-\n')
end

function UnitTester:iterate(examples, func)
	require 'libraryUtil'.checkType('iterate', 1, examples, 'table')
	if type(func) == 'string' then
		func = self[func]
	elseif type(func) ~= 'function' then
		error(("bad argument #2 to 'iterate' (expected function or string, got %s)")
			:format(type(func)), 2)
	end

	for i, example in ipairs(examples) do
		if type(example) == 'table' then
			func(self, unpack(example))
		elseif type(example) == 'string' then
			self:heading(example)
		else
			error(('bad example #%d (expected table, got %s)')
				:format(i, type(example)), 2)
		end
	end
end

function UnitTester:heading(text)
	result_table:insert_format(' ! colspan="%u" style="text-align: left;" | %s \n |- \n ',
		self.columns, text)
end

function UnitTester:runTest(name, test)
	local success, details = xpcall(function() test(self) end, function(err) return {error = err, trace = debug.traceback()} end)
	if not success then
		num_failures = num_failures + 1
		num_runs = num_runs + 1
		result_table:insert('| ', 'rowspan=2|', cross, ' \n| ', name, ' \n| ')
		result_table:insert_format(' colspan="%u"| <strong class="error">Lua error during testing -- %s;traceback:<br>%s</strong>\n',
			self.columns, details.error, frame:extensionTag("pre", details.trace or "(no traceback)"))
		result_table:insert('\n|-\n')
	end
end

function UnitTester:run(frame_arg)
	frame = frame_arg or mw.getCurrentFrame()
	self.frame = frame
	self.differs_at = frame.args['differs_at']
	self.live_sandbox = frame.args['live_sandbox']
	tick = frame:preprocess(cfg.successIndicator)
	cross = frame:preprocess(cfg.failureIndicator)

	local table_header = '{| class="wikitable unit-tests-result"\n|+ %s\n! !! '
	if self.live_sandbox then
		table_header = table_header .. cfg.testString .. ' !! ' .. cfg.liveString
			.. ' !! ' .. cfg.sandboxString .. ' !! ' .. cfg.expectedString
	else
		table_header = table_header .. cfg.testString .. ' !! ' .. cfg.expectedString .. ' !! ' .. cfg.actualString
	end
	if frame.args.highlight then
		should_highlight = true
	end

	self.columns = 4
	if self.differs_at then
		table_header = table_header .. ' !! ' .. cfg.differsString
		self.columns = self.columns + 1
	end
	if self._tests._last then
		table.insert(self._tests, self._tests._last)
		self._tests._last = nil
	end
	-- Add results to the results table.
	for _, testDetails in ipairs(self._tests) do
		result_table:insert_format('<h2>%s</h2>\n', testDetails.name)
		result_table:insert_format(table_header .. '\n|-\n', testDetails.name)
		self:runTest(testDetails.name, testDetails.test)
		result_table:insert('|}\n')
	end
	local refresh_link = tostring(mw.uri.fullUrl(mw.title.getCurrentTitle().fullText, 'action=purge&forcelinkupdate=1'))
	if self.live_sandbox then
		local live, sandbox
		if num_runs == 0 then
			live = cfg.noTestsRunSummary
		elseif num_failures ~= 0 then
			live = mw.message.newRawMessage(cfg.liveFailureSummary, num_runs, num_failures):plain()
			live = frame:preprocess(live)
		else
			live = mw.message.newRawMessage(cfg.liveSuccessSummary, num_runs):plain()
			live = frame:preprocess(live)
		end
		if num_runs == 0 then
			sandbox = ''
		elseif num_failures_sandbox ~= 0 then
			sandbox = mw.message.newRawMessage(cfg.sandboxFailureSummary, num_runs, num_failures_sandbox):plain()
			sandbox = frame:preprocess(sandbox)
		else
			sandbox = mw.message.newRawMessage(cfg.sandboxSuccessSummary, num_runs):plain()
			sandbox = frame:preprocess(sandbox)
		end
		local cat = (num_failures ~= 0 or num_failures_sandbox ~= 0) and
			(cfg.failureCategory .. " <span class='plainlinks unit-tests-refresh'>[" .. refresh_link .. " (refresh)]</span>") or ''
		return live .. ' ' .. sandbox .. cat .. '\n\n' .. frame:preprocess(result_table:concat())
	else
		local msg;
		if num_runs == 0 then
			msg = cfg.noTestsRunSummary
		elseif num_failures ~= 0 then
			msg = mw.message.newRawMessage(cfg.failureSummary, num_runs, num_failures):plain()
			msg = frame:preprocess(msg)
			msg = msg .. cfg.failureCategory
			msg = msg .. " <span class='plainlinks unit-tests-refresh'>[" .. refresh_link .. " (refresh)]</span>"
		else
			msg = mw.message.newRawMessage(cfg.successSummary, num_runs):plain()
			msg = frame:preprocess(msg)
		end
		return msg .. '\n\n' .. frame:preprocess(result_table:concat())
	end
end

-- Set up metatable
UnitTester.__meta = {}
UnitTester.__meta.__index = UnitTester
function UnitTester.__meta:__newindex(key, value)
	if type(key) == 'string' and key:find('^test') and type(value) == 'function' then
		-- Store test functions in the order they were defined
		if key == self.runLast or key == rawget(_G, "runLast") then
			self._tests._last = {name = key, test = value}
		else
			table.insert(self._tests, {name = key, test = value})
		end
	else
		rawset(self, key, value)
	end
end

function UnitTester.new()
	local o = {}
	o.runLast = '' -- puts a test at the end of the page
	o._tests = {}
	setmetatable(o, UnitTester.__meta)
	function o.run_tests(frame_arg) return o:run(frame_arg) end
	return o
end

local p = UnitTester.new()

return p