luaunit.lua

---@diagnostic disable
---@
--[[
        luaunit.lua

Description: A unit testing framework
Homepage: https://github.com/bluebird75/luaunit
Development by Philippe Fremy <phil@freehackers.org>
Based on initial work of Ryu, Gwang (http://www.gpgstudy.com/gpgiki/LuaUnit)
License: BSD License, see LICENSE.txt
]]
--

require("math")
local M = {}

-- private exported functions (for testing)
M.private = {}

M.VERSION = "3.4"
M._VERSION = M.VERSION -- For LuaUnit v2 compatibility

-- a version which distinguish between regular Lua and LuaJit
M._LUAVERSION = (jit and jit.version) or _VERSION

--[[ Some people like assertEquals( actual, expected ) and some people prefer
assertEquals( expected, actual ).
]]
--
M.ORDER_ACTUAL_EXPECTED = true
M.PRINT_TABLE_REF_IN_ERROR_MSG = false
M.LINE_LENGTH = 80
M.TABLE_DIFF_ANALYSIS_THRESHOLD = 10 -- display deep analysis for more than 10 items
M.LIST_DIFF_ANALYSIS_THRESHOLD = 10 -- display deep analysis for more than 10 items

-- this setting allow to remove entries from the stack-trace, for
-- example to hide a call to a framework which would be calling luaunit
M.STRIP_EXTRA_ENTRIES_IN_STACK_TRACE = 0

--[[ EPS is meant to help with Lua's floating point math in simple corner
cases like almostEquals(1.1-0.1, 1), which may not work as-is (e.g. on numbers
with rational binary representation) if the user doesn't provide some explicit
error margin.

The default margin used by almostEquals() in such cases is EPS; and since
Lua may be compiled with different numeric precisions (single vs. double), we
try to select a useful default for it dynamically. Note: If the initial value
is not acceptable, it can be changed by the user to better suit specific needs.

See also: https://en.wikipedia.org/wiki/Machine_epsilon
]]
M.EPS = 2 ^ -52 -- = machine epsilon for "double", ~2.22E-16
if math.abs(1.1 - 1 - 0.1) > M.EPS then
   -- rounding error is above EPS, assume single precision
   M.EPS = 2 ^ -23 -- = machine epsilon for "float", ~1.19E-07
end

-- set this to false to debug luaunit
local STRIP_LUAUNIT_FROM_STACKTRACE = true

M.VERBOSITY_DEFAULT = 10
M.VERBOSITY_LOW = 1
M.VERBOSITY_QUIET = 0
M.VERBOSITY_VERBOSE = 20
M.DEFAULT_DEEP_ANALYSIS = nil
M.FORCE_DEEP_ANALYSIS = true
M.DISABLE_DEEP_ANALYSIS = false

-- set EXPORT_ASSERT_TO_GLOBALS to have all asserts visible as global values
-- EXPORT_ASSERT_TO_GLOBALS = true

-- we need to keep a copy of the script args before it is overriden
local cmdline_argv = rawget(_G, "arg")

M.FAILURE_PREFIX = "LuaUnit test FAILURE: " -- prefix string for failed tests
M.SUCCESS_PREFIX = "LuaUnit test SUCCESS: " -- prefix string for successful tests finished early
M.SKIP_PREFIX = "LuaUnit test SKIP:    " -- prefix string for skipped tests

M.USAGE = [[Usage: lua <your_test_suite.lua> [options] [testname1 [testname2] ... ]
Options:
  -h, --help:             Print this help
  --version:              Print version information
  -v, --verbose:          Increase verbosity
  -q, --quiet:            Set verbosity to minimum
  -e, --error:            Stop on first error
  -f, --failure:          Stop on first failure or error
  -s, --shuffle:          Shuffle tests before running them
  -o, --output OUTPUT:    Set output type to OUTPUT
                          Possible values: text, tap, junit, nil
  -n, --name NAME:        For junit only, mandatory name of xml file
  -r, --repeat NUM:       Execute all tests NUM times, e.g. to trig the JIT
  -p, --pattern PATTERN:  Execute all test names matching the Lua PATTERN
                          May be repeated to include several patterns
                          Make sure you escape magic chars like +? with %
  -x, --exclude PATTERN:  Exclude all test names matching the Lua PATTERN
                          May be repeated to exclude several patterns
                          Make sure you escape magic chars like +? with %
  testname1, testname2, ... : tests to run in the form of testFunction,
                              TestClass or TestClass.testMethod

You may also control LuaUnit options with the following environment variables:
* LUAUNIT_OUTPUT: same as --output
* LUAUNIT_JUNIT_FNAME: same as --name ]]

----------------------------------------------------------------
--
--                 general utility functions
--
----------------------------------------------------------------

--[[ Note on catching exit

I have seen the case where running a big suite of test cases and one of them would
perform a os.exit(0), making the outside world think that the full test suite was executed
successfully.

This is an attempt to mitigate this problem: we override os.exit() to now let a test
exit the framework while we are running. When we are not running, it behaves normally.
]]

M.oldOsExit = os.exit
os.exit = function(...)
   if M.LuaUnit and #M.LuaUnit.instances ~= 0 then
      local msg = [[You are trying to exit but there is still a running instance of LuaUnit.
LuaUnit expects to run until the end before exiting with a complete status of successful/failed tests.

To force exit LuaUnit while running, please call before os.exit (assuming lu is the luaunit module loaded):

    lu.unregisterCurrentSuite() 

]]
      M.private.error_fmt(2, msg)
   end
   M.oldOsExit(...)
end

local function pcall_or_abort(func, ...)
   -- unpack is a global function for Lua 5.1, otherwise use table.unpack
   local unpack = rawget(_G, "unpack") or table.unpack
   local result = { pcall(func, ...) }
   if not result[1] then
      -- an error occurred
      print(result[2]) -- error message
      print()
      print(M.USAGE)
      os.exit(-1)
   end
   return unpack(result, 2)
end

local crossTypeOrdering = {
   number = 1,
   boolean = 2,
   string = 3,
   table = 4,
   other = 5,
}
local crossTypeComparison = {
   number = function(a, b)
      return a < b
   end,
   string = function(a, b)
      return a < b
   end,
   other = function(a, b)
      return tostring(a) < tostring(b)
   end,
}

local function crossTypeSort(a, b)
   local type_a, type_b = type(a), type(b)
   if type_a == type_b then
      local func = crossTypeComparison[type_a] or crossTypeComparison.other
      return func(a, b)
   end
   type_a = crossTypeOrdering[type_a] or crossTypeOrdering.other
   type_b = crossTypeOrdering[type_b] or crossTypeOrdering.other
   return type_a < type_b
end

local function __genSortedIndex(t)
   -- Returns a sequence consisting of t's keys, sorted.
   local sortedIndex = {}

   for key, _ in pairs(t) do
      table.insert(sortedIndex, key)
   end

   table.sort(sortedIndex, crossTypeSort)
   return sortedIndex
end
M.private.__genSortedIndex = __genSortedIndex

local function sortedNext(state, control)
   -- Equivalent of the next() function of table iteration, but returns the
   -- keys in sorted order (see __genSortedIndex and crossTypeSort).
   -- The state is a temporary variable during iteration and contains the
   -- sorted key table (state.sortedIdx). It also stores the last index (into
   -- the keys) used by the iteration, to find the next one quickly.
   local key

   --print("sortedNext: control = "..tostring(control) )
   if control == nil then
      -- start of iteration
      state.count = #state.sortedIdx
      state.lastIdx = 1
      key = state.sortedIdx[1]
      return key, state.t[key]
   end

   -- normally, we expect the control variable to match the last key used
   if control ~= state.sortedIdx[state.lastIdx] then
      -- strange, we have to find the next value by ourselves
      -- the key table is sorted in crossTypeSort() order! -> use bisection
      local lower, upper = 1, state.count
      repeat
         state.lastIdx = math.modf((lower + upper) / 2)
         key = state.sortedIdx[state.lastIdx]
         if key == control then
            break -- key found (and thus prev index)
         end
         if crossTypeSort(key, control) then
            -- key < control, continue search "right" (towards upper bound)
            lower = state.lastIdx + 1
         else
            -- key > control, continue search "left" (towards lower bound)
            upper = state.lastIdx - 1
         end
      until lower > upper
      if lower > upper then -- only true if the key wasn't found, ...
         state.lastIdx = state.count -- ... so ensure no match in code below
      end
   end

   -- proceed by retrieving the next value (or nil) from the sorted keys
   state.lastIdx = state.lastIdx + 1
   key = state.sortedIdx[state.lastIdx]
   if key then return key, state.t[key] end

   -- getting here means returning `nil`, which will end the iteration
end

local function sortedPairs(tbl)
   -- Equivalent of the pairs() function on tables. Allows to iterate in
   -- sorted order. As required by "generic for" loops, this will return the
   -- iterator (function), an "invariant state", and the initial control value.
   -- (see http://www.lua.org/pil/7.2.html)
   return sortedNext, { t = tbl, sortedIdx = __genSortedIndex(tbl) }, nil
end
M.private.sortedPairs = sortedPairs

-- seed the random with a strongly varying seed
math.randomseed(math.floor(os.clock() * 1E11))

local function randomizeTable(t)
   -- randomize the item orders of the table t
   for i = #t, 2, -1 do
      local j = math.random(i)
      if i ~= j then
         t[i], t[j] = t[j], t[i]
      end
   end
end
M.private.randomizeTable = randomizeTable

local function strsplit(delimiter, text)
   -- Split text into a list consisting of the strings in text, separated
   -- by strings matching delimiter (which may _NOT_ be a pattern).
   -- Example: strsplit(", ", "Anna, Bob, Charlie, Dolores")
   if delimiter == "" or delimiter == nil then -- this would result in endless loops
      error("delimiter is nil or empty string!")
   end
   if text == nil then return nil end

   local list, pos, first, last = {}, 1
   while true do
      first, last = text:find(delimiter, pos, true)
      if first then -- found?
         table.insert(list, text:sub(pos, first - 1))
         pos = last + 1
      else
         table.insert(list, text:sub(pos))
         break
      end
   end
   return list
end
M.private.strsplit = strsplit

local function hasNewLine(s)
   -- return true if s has a newline
   return (string.find(s, "\n", 1, true) ~= nil)
end
M.private.hasNewLine = hasNewLine

local function prefixString(prefix, s)
   -- Prefix all the lines of s with prefix
   return prefix .. string.gsub(s, "\n", "\n" .. prefix)
end
M.private.prefixString = prefixString

local function strMatch(s, pattern, start, final)
   -- return true if s matches completely the pattern from index start to index end
   -- return false in every other cases
   -- if start is nil, matches from the beginning of the string
   -- if final is nil, matches to the end of the string
   start = start or 1
   final = final or string.len(s)

   local foundStart, foundEnd = string.find(s, pattern, start, false)
   return foundStart == start and foundEnd == final
end
M.private.strMatch = strMatch

local function patternFilter(patterns, expr)
   -- Run `expr` through the inclusion and exclusion rules defined in patterns
   -- and return true if expr shall be included, false for excluded.
   -- Inclusion pattern are defined as normal patterns, exclusions
   -- patterns start with `!` and are followed by a normal pattern

   -- result: nil = UNKNOWN (not matched yet), true = ACCEPT, false = REJECT
   -- default: true if no explicit "include" is found, set to false otherwise
   local default, result = true, nil

   if patterns ~= nil then
      for _, pattern in ipairs(patterns) do
         local exclude = pattern:sub(1, 1) == "!"
         if exclude then
            pattern = pattern:sub(2)
         else
            -- at least one include pattern specified, a match is required
            default = false
         end
         -- print('pattern: ',pattern)
         -- print('exclude: ',exclude)
         -- print('default: ',default)

         if string.find(expr, pattern) then
            -- set result to false when excluding, true otherwise
            result = not exclude
         end
      end
   end

   if result ~= nil then return result end
   return default
end
M.private.patternFilter = patternFilter

local function xmlEscape(s)
   -- Return s escaped for XML attributes
   -- escapes table:
   -- "   &quot;
   -- '   &apos;
   -- <   &lt;
   -- >   &gt;
   -- &   &amp;

   return string.gsub(s, ".", {
      ["&"] = "&amp;",
      ['"'] = "&quot;",
      ["'"] = "&apos;",
      ["<"] = "&lt;",
      [">"] = "&gt;",
   })
end
M.private.xmlEscape = xmlEscape

local function xmlCDataEscape(s)
   -- Return s escaped for CData section, escapes: "]]>"
   return string.gsub(s, "]]>", "]]&gt;")
end
M.private.xmlCDataEscape = xmlCDataEscape

local function lstrip(s)
   --[[Return s with all leading white spaces and tabs removed]]
   local idx = 0
   while idx < s:len() do
      idx = idx + 1
      local c = s:sub(idx, idx)
      if c ~= " " and c ~= "\t" then break end
   end
   return s:sub(idx)
end
M.private.lstrip = lstrip

local function extractFileLineInfo(s)
   --[[ From a string in the form "(leading spaces) dir1/dir2\dir3\file.lua:linenb: msg"

    Return the "file.lua:linenb" information
    ]]
   local s2 = lstrip(s)
   local firstColon = s2:find(":", 1, true)
   if firstColon == nil then
      -- string is not in the format file:line:
      return s
   end
   local secondColon = s2:find(":", firstColon + 1, true)
   if secondColon == nil then
      -- string is not in the format file:line:
      return s
   end

   return s2:sub(1, secondColon - 1)
end
M.private.extractFileLineInfo = extractFileLineInfo

local function stripLuaunitTrace2(stackTrace, errMsg)
   --[[
    -- Example of  a traceback:
    <<stack traceback:
        example_with_luaunit.lua:130: in function 'test2_withFailure'
        ./luaunit.lua:1449: in function <./luaunit.lua:1449>
        [C]: in function 'xpcall'
        ./luaunit.lua:1449: in function 'protectedCall'
        ./luaunit.lua:1508: in function 'execOneFunction'
        ./luaunit.lua:1596: in function 'runSuiteByInstances'
        ./luaunit.lua:1660: in function 'runSuiteByNames'
        ./luaunit.lua:1736: in function 'runSuite'
        example_with_luaunit.lua:140: in main chunk
        [C]: in ?>>
    error message: <<example_with_luaunit.lua:130: expected 2, got 1>>

        Other example:
    <<stack traceback:
        ./luaunit.lua:545: in function 'assertEquals'
        example_with_luaunit.lua:58: in function 'TestToto.test7'
        ./luaunit.lua:1517: in function <./luaunit.lua:1517>
        [C]: in function 'xpcall'
        ./luaunit.lua:1517: in function 'protectedCall'
        ./luaunit.lua:1578: in function 'execOneFunction'
        ./luaunit.lua:1677: in function 'runSuiteByInstances'
        ./luaunit.lua:1730: in function 'runSuiteByNames'
        ./luaunit.lua:1806: in function 'runSuite'
        example_with_luaunit.lua:140: in main chunk
        [C]: in ?>>
    error message: <<example_with_luaunit.lua:58:  expected 2, got 1>>

    <<stack traceback:
        luaunit2/example_with_luaunit.lua:124: in function 'test1_withFailure'
        luaunit2/luaunit.lua:1532: in function <luaunit2/luaunit.lua:1532>
        [C]: in function 'xpcall'
        luaunit2/luaunit.lua:1532: in function 'protectedCall'
        luaunit2/luaunit.lua:1591: in function 'execOneFunction'
        luaunit2/luaunit.lua:1679: in function 'runSuiteByInstances'
        luaunit2/luaunit.lua:1743: in function 'runSuiteByNames'
        luaunit2/luaunit.lua:1819: in function 'runSuite'
        luaunit2/example_with_luaunit.lua:140: in main chunk
        [C]: in ?>>
    error message: <<luaunit2/example_with_luaunit.lua:124:  expected 2, got 1>>


    -- first line is "stack traceback": KEEP
    -- next line may be luaunit line: REMOVE
    -- next lines are call in the program under testOk: REMOVE
    -- next lines are calls from luaunit to call the program under test: KEEP

    -- Strategy:
    -- keep first line
    -- remove lines that are part of luaunit
    -- kepp lines until we hit a luaunit line

    The strategy for stripping is:
    * keep first line "stack traceback:"
    * part1:
        * analyse all lines of the stack from bottom to top of the stack (first line to last line)
        * extract the "file:line:" part of the line
        * compare it with the "file:line" part of the error message
        * if it does not match strip the line
        * if it matches, keep the line and move to part 2
    * part2:
        * anything NOT starting with luaunit.lua is the interesting part of the stack trace
        * anything starting again with luaunit.lua is part of the test launcher and should be stripped out
    ]]

   local function isLuaunitInternalLine(s)
      -- return true if line of stack trace comes from inside luaunit
      return s:find("[/\\]luaunit%.lua:%d+: ") ~= nil
   end

   -- print( '<<'..stackTrace..'>>' )

   local t = strsplit("\n", stackTrace)
   -- print( prettystr(t) )

   local idx = 2

   local errMsgFileLine = extractFileLineInfo(errMsg)
   -- print('emfi="'..errMsgFileLine..'"')

   -- remove lines that are still part of luaunit
   while t[idx] and extractFileLineInfo(t[idx]) ~= errMsgFileLine do
      -- print('Removing : '..t[idx] )
      table.remove(t, idx)
   end

   -- keep lines until we hit luaunit again
   while t[idx] and (not isLuaunitInternalLine(t[idx])) do
      -- print('Keeping : '..t[idx] )
      idx = idx + 1
   end

   -- remove remaining luaunit lines
   while t[idx] do
      -- print('Removing2 : '..t[idx] )
      table.remove(t, idx)
   end

   -- print( prettystr(t) )
   return table.concat(t, "\n")
end
M.private.stripLuaunitTrace2 = stripLuaunitTrace2

local function prettystr_sub(v, indentLevel, printTableRefs, cycleDetectTable)
   local type_v = type(v)
   if "string" == type_v then
      -- use clever delimiters according to content:
      -- enclose with single quotes if string contains ", but no '
      if v:find('"', 1, true) and not v:find("'", 1, true) then return "'" .. v .. "'" end
      -- use double quotes otherwise, escape embedded "
      return '"' .. v:gsub('"', '\\"') .. '"'
   elseif "table" == type_v then
      --if v.__class__ then
      --    return string.gsub( tostring(v), 'table', v.__class__ )
      --end
      return M.private._table_tostring(v, indentLevel, printTableRefs, cycleDetectTable)
   elseif "number" == type_v then
      -- eliminate differences in formatting between various Lua versions
      if v ~= v then
         return "#NaN" -- "not a number"
      end
      if v == math.huge then
         return "#Inf" -- "infinite"
      end
      if v == -math.huge then return "-#Inf" end
      if _VERSION == "Lua 5.3" then
         local i = math.tointeger(v)
         if i then return tostring(i) end
      end
   end

   return tostring(v)
end

local function prettystr(v)
   --[[ Pretty string conversion, to display the full content of a variable of any type.

    * string are enclosed with " by default, or with ' if string contains a "
    * tables are expanded to show their full content, with indentation in case of nested tables
    ]]
   --
   local cycleDetectTable = {}
   local s = prettystr_sub(v, 1, M.PRINT_TABLE_REF_IN_ERROR_MSG, cycleDetectTable)
   if cycleDetectTable.detected and not M.PRINT_TABLE_REF_IN_ERROR_MSG then
      -- some table contain recursive references,
      -- so we must recompute the value by including all table references
      -- else the result looks like crap
      cycleDetectTable = {}
      s = prettystr_sub(v, 1, true, cycleDetectTable)
   end
   return s
end
M.prettystr = prettystr

function M.adjust_err_msg_with_iter(err_msg, iter_msg)
   --[[ Adjust the error message err_msg: trim the FAILURE_PREFIX or SUCCESS_PREFIX information if needed, 
    add the iteration message if any and return the result.

    err_msg:  string, error message captured with pcall
    iter_msg: a string describing the current iteration ("iteration N") or nil
              if there is no iteration in this test.

    Returns: (new_err_msg, test_status)
        new_err_msg: string, adjusted error message, or nil in case of success
        test_status: M.NodeStatus.FAIL, SUCCESS or ERROR according to the information
                     contained in the error message.
    ]]
   if iter_msg then
      iter_msg = iter_msg .. ", "
   else
      iter_msg = ""
   end

   local RE_FILE_LINE = ".*:%d+: "

   -- error message is not necessarily a string,
   -- so convert the value to string with prettystr()
   if type(err_msg) ~= "string" then err_msg = prettystr(err_msg) end

   if
      (err_msg:find(M.SUCCESS_PREFIX) == 1) or err_msg:match("(" .. RE_FILE_LINE .. ")" .. M.SUCCESS_PREFIX .. ".*")
   then
      -- test finished early with success()
      return nil, M.NodeStatus.SUCCESS
   end

   if
      (err_msg:find(M.SKIP_PREFIX) == 1) or (err_msg:match("(" .. RE_FILE_LINE .. ")" .. M.SKIP_PREFIX .. ".*") ~= nil)
   then
      -- substitute prefix by iteration message
      err_msg = err_msg:gsub(".*" .. M.SKIP_PREFIX, iter_msg, 1)
      -- print("failure detected")
      return err_msg, M.NodeStatus.SKIP
   end

   if
      (err_msg:find(M.FAILURE_PREFIX) == 1)
      or (err_msg:match("(" .. RE_FILE_LINE .. ")" .. M.FAILURE_PREFIX .. ".*") ~= nil)
   then
      -- substitute prefix by iteration message
      err_msg = err_msg:gsub(M.FAILURE_PREFIX, iter_msg, 1)
      -- print("failure detected")
      return err_msg, M.NodeStatus.FAIL
   end

   -- print("error detected")
   -- regular error, not a failure
   if iter_msg then
      local match
      -- "./test\\test_luaunit.lua:2241: some error msg
      match = err_msg:match("(.*:%d+: ).*")
      if match then
         err_msg = err_msg:gsub(match, match .. iter_msg)
      else
         -- no file:line: infromation, just add the iteration info at the beginning of the line
         err_msg = iter_msg .. err_msg
      end
   end
   return err_msg, M.NodeStatus.ERROR
end

local function tryMismatchFormatting(table_a, table_b, doDeepAnalysis, margin)
   --[[
    Prepares a nice error message when comparing tables, performing a deeper 
    analysis.

    Arguments:
    * table_a, table_b: tables to be compared
    * doDeepAnalysis:
        M.DEFAULT_DEEP_ANALYSIS: (the default if not specified) perform deep analysis only for big lists and big dictionnaries
        M.FORCE_DEEP_ANALYSIS  : always perform deep analysis
        M.DISABLE_DEEP_ANALYSIS: never perform deep analysis
    * margin: supplied only for almost equality

    Returns: {success, result}
    * success: false if deep analysis could not be performed 
               in this case, just use standard assertion message
    * result: if success is true, a multi-line string with deep analysis of the two lists
    ]]

   -- check if table_a & table_b are suitable for deep analysis
   if type(table_a) ~= "table" or type(table_b) ~= "table" then return false end

   if doDeepAnalysis == M.DISABLE_DEEP_ANALYSIS then return false end

   local len_a, len_b, isPureList = #table_a, #table_b, true

   for k1, v1 in pairs(table_a) do
      if type(k1) ~= "number" or k1 > len_a then
         -- this table a mapping
         isPureList = false
         break
      end
   end

   if isPureList then
      for k2, v2 in pairs(table_b) do
         if type(k2) ~= "number" or k2 > len_b then
            -- this table a mapping
            isPureList = false
            break
         end
      end
   end

   if isPureList and math.min(len_a, len_b) < M.LIST_DIFF_ANALYSIS_THRESHOLD then
      if not (doDeepAnalysis == M.FORCE_DEEP_ANALYSIS) then return false end
   end

   if isPureList then
      return M.private.mismatchFormattingPureList(table_a, table_b, margin)
   else
      -- only work on mapping for the moment
      -- return M.private.mismatchFormattingMapping( table_a, table_b, doDeepAnalysis )
      return false
   end
end
M.private.tryMismatchFormatting = tryMismatchFormatting

local function getTaTbDescr()
   if not M.ORDER_ACTUAL_EXPECTED then return "expected", "actual" end
   return "actual", "expected"
end

local function extendWithStrFmt(res, ...)
   table.insert(res, string.format(...))
end

local function mismatchFormattingMapping(table_a, table_b, doDeepAnalysis)
   --[[
    Prepares a nice error message when comparing tables which are not pure lists, performing a deeper 
    analysis.

    Returns: {success, result}
    * success: false if deep analysis could not be performed 
               in this case, just use standard assertion message
    * result: if success is true, a multi-line string with deep analysis of the two lists
    ]]

   -- disable for the moment
   --[[
    local result = {}
    local descrTa, descrTb = getTaTbDescr()

    local keysCommon = {}
    local keysOnlyTa = {}
    local keysOnlyTb = {}
    local keysDiffTaTb = {}

    local k, v

    for k,v in pairs( table_a ) do
        if is_equal( v, table_b[k] ) then
            table.insert( keysCommon, k )
        else 
            if table_b[k] == nil then
                table.insert( keysOnlyTa, k )
            else
                table.insert( keysDiffTaTb, k )
            end
        end
    end

    for k,v in pairs( table_b ) do
        if not is_equal( v, table_a[k] ) and table_a[k] == nil then
            table.insert( keysOnlyTb, k )
        end
    end

    local len_a = #keysCommon + #keysDiffTaTb + #keysOnlyTa
    local len_b = #keysCommon + #keysDiffTaTb + #keysOnlyTb
    local limited_display = (len_a < 5 or len_b < 5)

    if math.min(len_a, len_b) < M.TABLE_DIFF_ANALYSIS_THRESHOLD then
        return false
    end

    if not limited_display then
        if len_a == len_b then
            extendWithStrFmt( result, 'Table A (%s) and B (%s) both have %d items', descrTa, descrTb, len_a )
        else
            extendWithStrFmt( result, 'Table A (%s) has %d items and table B (%s) has %d items', descrTa, len_a, descrTb, len_b )
            end

        if #keysCommon == 0 and #keysDiffTaTb == 0 then
            table.insert( result, 'Table A and B have no keys in common, they are totally different')
        else
            local s_other = 'other '
            if #keysCommon then
                extendWithStrFmt( result, 'Table A and B have %d identical items', #keysCommon )
            else
                table.insert( result, 'Table A and B have no identical items' )
                s_other = ''
            end

            if #keysDiffTaTb ~= 0 then
                result[#result] = string.format( '%s and %d items differing present in both tables', result[#result], #keysDiffTaTb)
            else
                result[#result] = string.format( '%s and no %sitems differing present in both tables', result[#result], s_other, #keysDiffTaTb)
            end
        end

        extendWithStrFmt( result, 'Table A has %d keys not present in table B and table B has %d keys not present in table A', #keysOnlyTa, #keysOnlyTb ) 
    end

    local function keytostring(k)
        if "string" == type(k) and k:match("^[_%a][_%w]*$") then
            return k
        end
        return prettystr(k)
    end

    if #keysDiffTaTb ~= 0 then
        table.insert( result, 'Items differing in A and B:')
        for k,v in sortedPairs( keysDiffTaTb ) do
            extendWithStrFmt( result, '  - A[%s]: %s', keytostring(v), prettystr(table_a[v]) )
            extendWithStrFmt( result, '  + B[%s]: %s', keytostring(v), prettystr(table_b[v]) )
        end
    end    

    if #keysOnlyTa ~= 0 then
        table.insert( result, 'Items only in table A:' )
        for k,v in sortedPairs( keysOnlyTa ) do
            extendWithStrFmt( result, '  - A[%s]: %s', keytostring(v), prettystr(table_a[v]) )
        end
    end

    if #keysOnlyTb ~= 0 then
        table.insert( result, 'Items only in table B:' )
        for k,v in sortedPairs( keysOnlyTb ) do
            extendWithStrFmt( result, '  + B[%s]: %s', keytostring(v), prettystr(table_b[v]) )
        end
    end

    if #keysCommon ~= 0 then
        table.insert( result, 'Items common to A and B:')
        for k,v in sortedPairs( keysCommon ) do
            extendWithStrFmt( result, '  = A and B [%s]: %s', keytostring(v), prettystr(table_a[v]) )
        end
    end    

    return true, table.concat( result, '\n')
    ]]
end
M.private.mismatchFormattingMapping = mismatchFormattingMapping

local function mismatchFormattingPureList(table_a, table_b, margin)
   --[[
    Prepares a nice error message when comparing tables which are lists, performing a deeper 
    analysis.

    margin is supplied only for almost equality

    Returns: {success, result}
    * success: false if deep analysis could not be performed 
               in this case, just use standard assertion message
    * result: if success is true, a multi-line string with deep analysis of the two lists
    ]]
   local result, descrTa, descrTb = {}, getTaTbDescr()

   local len_a, len_b, refa, refb = #table_a, #table_b, "", ""
   if M.PRINT_TABLE_REF_IN_ERROR_MSG then
      refa, refb =
         string.format("<%s> ", M.private.table_ref(table_a)), string.format("<%s> ", M.private.table_ref(table_b))
   end
   local longest, shortest = math.max(len_a, len_b), math.min(len_a, len_b)
   local deltalv = longest - shortest

   local commonUntil = shortest
   for i = 1, shortest do
      if not M.private.is_table_equals(table_a[i], table_b[i], margin) then
         commonUntil = i - 1
         break
      end
   end

   local commonBackTo = shortest - 1
   for i = 0, shortest - 1 do
      if not M.private.is_table_equals(table_a[len_a - i], table_b[len_b - i], margin) then
         commonBackTo = i - 1
         break
      end
   end

   table.insert(result, "List difference analysis:")
   if len_a == len_b then
      -- TODO: handle expected/actual naming
      extendWithStrFmt(result, "* lists %sA (%s) and %sB (%s) have the same size", refa, descrTa, refb, descrTb)
   else
      extendWithStrFmt(
         result,
         "* list sizes differ: list %sA (%s) has %d items, list %sB (%s) has %d items",
         refa,
         descrTa,
         len_a,
         refb,
         descrTb,
         len_b
      )
   end

   extendWithStrFmt(result, "* lists A and B start differing at index %d", commonUntil + 1)
   if commonBackTo >= 0 then
      if deltalv > 0 then
         extendWithStrFmt(
            result,
            "* lists A and B are equal again from index %d for A, %d for B",
            len_a - commonBackTo,
            len_b - commonBackTo
         )
      else
         extendWithStrFmt(result, "* lists A and B are equal again from index %d", len_a - commonBackTo)
      end
   end

   local function insertABValue(ai, bi)
      bi = bi or ai
      if M.private.is_table_equals(table_a[ai], table_b[bi], margin) then
         return extendWithStrFmt(result, "  = A[%d], B[%d]: %s", ai, bi, prettystr(table_a[ai]))
      else
         extendWithStrFmt(result, "  - A[%d]: %s", ai, prettystr(table_a[ai]))
         extendWithStrFmt(result, "  + B[%d]: %s", bi, prettystr(table_b[bi]))
      end
   end

   -- common parts to list A & B, at the beginning
   if commonUntil > 0 then
      table.insert(result, "* Common parts:")
      for i = 1, commonUntil do
         insertABValue(i)
      end
   end

   -- diffing parts to list A & B
   if commonUntil < shortest - commonBackTo - 1 then
      table.insert(result, "* Differing parts:")
      for i = commonUntil + 1, shortest - commonBackTo - 1 do
         insertABValue(i)
      end
   end

   -- display indexes of one list, with no match on other list
   if shortest - commonBackTo <= longest - commonBackTo - 1 then
      table.insert(result, "* Present only in one list:")
      for i = shortest - commonBackTo, longest - commonBackTo - 1 do
         if len_a > len_b then
            extendWithStrFmt(result, "  - A[%d]: %s", i, prettystr(table_a[i]))
            -- table.insert( result, '+ (no matching B index)')
         else
            -- table.insert( result, '- no matching A index')
            extendWithStrFmt(result, "  + B[%d]: %s", i, prettystr(table_b[i]))
         end
      end
   end

   -- common parts to list A & B, at the end
   if commonBackTo >= 0 then
      table.insert(result, "* Common parts at the end of the lists")
      for i = longest - commonBackTo, longest do
         if len_a > len_b then
            insertABValue(i, i - deltalv)
         else
            insertABValue(i - deltalv, i)
         end
      end
   end

   return true, table.concat(result, "\n")
end
M.private.mismatchFormattingPureList = mismatchFormattingPureList

local function prettystrPairs(value1, value2, suffix_a, suffix_b)
   --[[
    This function helps with the recurring task of constructing the "expected
    vs. actual" error messages. It takes two arbitrary values and formats
    corresponding strings with prettystr().

    To keep the (possibly complex) output more readable in case the resulting
    strings contain line breaks, they get automatically prefixed with additional
    newlines. Both suffixes are optional (default to empty strings), and get
    appended to the "value1" string. "suffix_a" is used if line breaks were
    encountered, "suffix_b" otherwise.

    Returns the two formatted strings (including padding/newlines).
    ]]
   local str1, str2 = prettystr(value1), prettystr(value2)
   if hasNewLine(str1) or hasNewLine(str2) then
      -- line break(s) detected, add padding
      return "\n" .. str1 .. (suffix_a or ""), "\n" .. str2
   end
   return str1 .. (suffix_b or ""), str2
end
M.private.prettystrPairs = prettystrPairs

local UNKNOWN_REF = "table 00-unknown ref"
local ref_generator = { value = 1, [UNKNOWN_REF] = 0 }

local function table_ref(t)
   -- return the default tostring() for tables, with the table ID, even if the table has a metatable
   -- with the __tostring converter
   local ref = ""
   local mt = getmetatable(t)
   if mt == nil then
      ref = tostring(t)
   else
      local success, result
      success, result = pcall(setmetatable, t, nil)
      if not success then
         -- protected table, if __tostring is defined, we can
         -- not get the reference. And we can not know in advance.
         ref = tostring(t)
         if not ref:match("table: 0?x?[%x]+") then return UNKNOWN_REF end
      else
         ref = tostring(t)
         setmetatable(t, mt)
      end
   end
   -- strip the "table: " part
   ref = ref:sub(8)
   if ref ~= UNKNOWN_REF and ref_generator[ref] == nil then
      -- Create a new reference number
      ref_generator[ref] = ref_generator.value
      ref_generator.value = ref_generator.value + 1
   end
   if M.PRINT_TABLE_REF_IN_ERROR_MSG then
      return string.format("table %02d-%s", ref_generator[ref], ref)
   else
      return string.format("table %02d", ref_generator[ref])
   end
end
M.private.table_ref = table_ref

local TABLE_TOSTRING_SEP = ", "
local TABLE_TOSTRING_SEP_LEN = string.len(TABLE_TOSTRING_SEP)

local function _table_tostring(tbl, indentLevel, printTableRefs, cycleDetectTable)
   printTableRefs = printTableRefs or M.PRINT_TABLE_REF_IN_ERROR_MSG
   cycleDetectTable = cycleDetectTable or {}
   cycleDetectTable[tbl] = true

   local result, dispOnMultLines = {}, false

   -- like prettystr but do not enclose with "" if the string is just alphanumerical
   -- this is better for displaying table keys who are often simple strings
   local function keytostring(k)
      if "string" == type(k) and k:match("^[_%a][_%w]*$") then return k end
      return prettystr_sub(k, indentLevel + 1, printTableRefs, cycleDetectTable)
   end

   local mt = getmetatable(tbl)

   if mt and mt.__tostring then
      -- if table has a __tostring() function in its metatable, use it to display the table
      -- else, compute a regular table
      result = tostring(tbl)
      if type(result) ~= "string" then return string.format('<invalid tostring() result: "%s" >', prettystr(result)) end
      result = strsplit("\n", result)
      return M.private._table_tostring_format_multiline_string(result, indentLevel)
   else
      -- no metatable, compute the table representation

      local entry, count, seq_index = nil, 0, 1
      for k, v in sortedPairs(tbl) do
         -- key part
         if k == seq_index then
            -- for the sequential part of tables, we'll skip the "<key>=" output
            entry = ""
            seq_index = seq_index + 1
         elseif cycleDetectTable[k] then
            -- recursion in the key detected
            cycleDetectTable.detected = true
            entry = "<" .. table_ref(k) .. ">="
         else
            entry = keytostring(k) .. "="
         end

         -- value part
         if cycleDetectTable[v] then
            -- recursion in the value detected!
            cycleDetectTable.detected = true
            entry = entry .. "<" .. table_ref(v) .. ">"
         else
            entry = entry .. prettystr_sub(v, indentLevel + 1, printTableRefs, cycleDetectTable)
         end
         count = count + 1
         result[count] = entry
      end
      return M.private._table_tostring_format_result(tbl, result, indentLevel, printTableRefs)
   end
end
M.private._table_tostring = _table_tostring -- prettystr_sub() needs it

local function _table_tostring_format_multiline_string(tbl_str, indentLevel)
   local indentString = "\n" .. string.rep("    ", indentLevel - 1)
   return table.concat(tbl_str, indentString)
end
M.private._table_tostring_format_multiline_string = _table_tostring_format_multiline_string

local function _table_tostring_format_result(tbl, result, indentLevel, printTableRefs)
   -- final function called in _table_to_string() to format the resulting list of
   -- string describing the table.

   local dispOnMultLines = false

   -- set dispOnMultLines to true if the maximum LINE_LENGTH would be exceeded with the values
   local totalLength = 0
   for k, v in ipairs(result) do
      totalLength = totalLength + string.len(v)
      if totalLength >= M.LINE_LENGTH then
         dispOnMultLines = true
         break
      end
   end

   -- set dispOnMultLines to true if the max LINE_LENGTH would be exceeded
   -- with the values and the separators.
   if not dispOnMultLines then
      -- adjust with length of separator(s):
      -- two items need 1 sep, three items two seps, ... plus len of '{}'
      if #result > 0 then totalLength = totalLength + TABLE_TOSTRING_SEP_LEN * (#result - 1) end
      dispOnMultLines = (totalLength + 2 >= M.LINE_LENGTH)
   end

   -- now reformat the result table (currently holding element strings)
   if dispOnMultLines then
      local indentString = string.rep("    ", indentLevel - 1)
      result = {
         "{\n    ",
         indentString,
         table.concat(result, ",\n    " .. indentString),
         "\n",
         indentString,
         "}",
      }
   else
      result = { "{", table.concat(result, TABLE_TOSTRING_SEP), "}" }
   end
   if printTableRefs then
      table.insert(result, 1, "<" .. table_ref(tbl) .. "> ") -- prepend table ref
   end
   return table.concat(result)
end
M.private._table_tostring_format_result = _table_tostring_format_result -- prettystr_sub() needs it

local function table_findkeyof(t, element)
   -- Return the key k of the given element in table t, so that t[k] == element
   -- (or `nil` if element is not present within t). Note that we use our
   -- 'general' is_equal comparison for matching, so this function should
   -- handle table-type elements gracefully and consistently.
   if type(t) == "table" then
      for k, v in pairs(t) do
         if M.private.is_table_equals(v, element) then return k end
      end
   end
   return nil
end

local function _is_table_items_equals(actual, expected)
   local type_a, type_e = type(actual), type(expected)

   if type_a ~= type_e then
      return false
   elseif
      type_a == "table" --[[and (type_e == 'table')]]
   then
      for k, v in pairs(actual) do
         if table_findkeyof(expected, v) == nil then
            return false -- v not contained in expected
         end
      end
      for k, v in pairs(expected) do
         if table_findkeyof(actual, v) == nil then
            return false -- v not contained in actual
         end
      end
      return true
   elseif actual ~= expected then
      return false
   end

   return true
end

--[[
This is a specialized metatable to help with the bookkeeping of recursions
in _is_table_equals(). It provides an __index table that implements utility
functions for easier management of the table. The "cached" method queries
the state of a specific (actual,expected) pair; and the "store" method sets
this state to the given value. The state of pairs not "seen" / visited is
assumed to be `nil`.
]]
local _recursion_cache_MT = {
   __index = {
      -- Return the cached value for an (actual,expected) pair (or `nil`)
      cached = function(t, actual, expected)
         local subtable = t[actual] or {}
         return subtable[expected]
      end,

      -- Store cached value for a specific (actual,expected) pair.
      -- Returns the value, so it's easy to use for a "tailcall" (return ...).
      store = function(t, actual, expected, value, asymmetric)
         local subtable = t[actual]
         if not subtable then
            subtable = {}
            t[actual] = subtable
         end
         subtable[expected] = value

         -- Unless explicitly marked "asymmetric": Consider the recursion
         -- on (expected,actual) to be equivalent to (actual,expected) by
         -- default, and thus cache the value for both.
         if not asymmetric then t:store(expected, actual, value, true) end

         return value
      end,
   },
}

local function _is_table_equals(actual, expected, cycleDetectTable, marginForAlmostEqual)
   --[[Returns true if both table are equal.

    If argument marginForAlmostEqual is suppied, number comparison is done using alomstEqual instead 
    of strict equality.

    cycleDetectTable is an internal argument used during recursion on tables.
    ]]
   --print('_is_table_equals( \n     '..prettystr(actual)..'\n      , '..prettystr(expected)..
   --                        '\n     , '..prettystr(cycleDetectTable)..'\n    , '..prettystr(marginForAlmostEqual)..' )')

   local type_a, type_e = type(actual), type(expected)

   if type_a ~= type_e then
      return false -- different types won't match
   end

   if type_a == "number" then
      if marginForAlmostEqual ~= nil then
         return M.almostEquals(actual, expected, marginForAlmostEqual)
      else
         return actual == expected
      end
   elseif type_a ~= "table" then
      -- other types compare directly
      return actual == expected
   end

   cycleDetectTable = cycleDetectTable or { actual = {}, expected = {} }
   if cycleDetectTable.actual[actual] then
      -- oh, we hit a cycle in actual
      if cycleDetectTable.expected[expected] then
         -- uh, we hit a cycle at the same time in expected
         -- so the two tables have similar structure
         return true
      end

      -- cycle was hit only in actual, the structure differs from expected
      return false
   end

   if cycleDetectTable.expected[expected] then
      -- no cycle in actual, but cycle in expected
      -- the structure differ
      return false
   end

   -- at this point, no table cycle detected, we are
   -- seeing this table for the first time

   -- mark the cycle detection
   cycleDetectTable.actual[actual] = true
   cycleDetectTable.expected[expected] = true

   local actualKeysMatched = {}
   for k, v in pairs(actual) do
      actualKeysMatched[k] = true -- Keep track of matched keys
      if not _is_table_equals(v, expected[k], cycleDetectTable, marginForAlmostEqual) then
         -- table differs on this key
         -- clear the cycle detection before returning
         cycleDetectTable.actual[actual] = nil
         cycleDetectTable.expected[expected] = nil
         return false
      end
   end

   for k, v in pairs(expected) do
      if not actualKeysMatched[k] then
         -- Found a key that we did not see in "actual" -> mismatch
         -- clear the cycle detection before returning
         cycleDetectTable.actual[actual] = nil
         cycleDetectTable.expected[expected] = nil
         return false
      end
      -- Otherwise actual[k] was already matched against v = expected[k].
   end

   -- all key match, we have a match !
   cycleDetectTable.actual[actual] = nil
   cycleDetectTable.expected[expected] = nil
   return true
end
M.private._is_table_equals = _is_table_equals

local function failure(main_msg, extra_msg_or_nil, level)
   -- raise an error indicating a test failure
   -- for error() compatibility we adjust "level" here (by +1), to report the
   -- calling context
   local msg
   if type(extra_msg_or_nil) == "string" and extra_msg_or_nil:len() > 0 then
      msg = extra_msg_or_nil .. "\n" .. main_msg
   else
      msg = main_msg
   end
   error(M.FAILURE_PREFIX .. msg, (level or 1) + 1 + M.STRIP_EXTRA_ENTRIES_IN_STACK_TRACE)
end

local function is_table_equals(actual, expected, marginForAlmostEqual)
   return _is_table_equals(actual, expected, nil, marginForAlmostEqual)
end
M.private.is_table_equals = is_table_equals

local function fail_fmt(level, extra_msg_or_nil, ...)
   -- failure with printf-style formatted message and given error level
   failure(string.format(...), extra_msg_or_nil, (level or 1) + 1)
end
M.private.fail_fmt = fail_fmt

local function error_fmt(level, ...)
   -- printf-style error()
   error(string.format(...), (level or 1) + 1 + M.STRIP_EXTRA_ENTRIES_IN_STACK_TRACE)
end
M.private.error_fmt = error_fmt

----------------------------------------------------------------
--
--                     assertions
--
----------------------------------------------------------------

local function errorMsgEquality(actual, expected, doDeepAnalysis, margin)
   -- margin is supplied only for almost equal verification

   if not M.ORDER_ACTUAL_EXPECTED then
      expected, actual = actual, expected
   end
   if type(expected) == "string" or type(expected) == "table" then
      local strExpected, strActual = prettystrPairs(expected, actual)
      local result = string.format("expected: %s\nactual: %s", strExpected, strActual)
      if margin then result = result .. "\nwere not equal by the margin of: " .. prettystr(margin) end

      -- extend with mismatch analysis if possible:
      local success, mismatchResult
      success, mismatchResult = tryMismatchFormatting(actual, expected, doDeepAnalysis, margin)
      if success then result = table.concat({ result, mismatchResult }, "\n") end
      return result
   end
   return string.format("expected: %s, actual: %s", prettystr(expected), prettystr(actual))
end

function M.assertError(f, ...)
   -- assert that calling f with the arguments will raise an error
   -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error
   if pcall(f, ...) then failure("Expected an error when calling function but no error generated", nil, 2) end
end

function M.fail(msg)
   -- stops a test due to a failure
   failure(msg, nil, 2)
end

function M.failIf(cond, msg)
   -- Fails a test with "msg" if condition is true
   if cond then failure(msg, nil, 2) end
end

function M.skip(msg)
   -- skip a running test
   error_fmt(2, M.SKIP_PREFIX .. msg)
end

function M.skipIf(cond, msg)
   -- skip a running test if condition is met
   if cond then error_fmt(2, M.SKIP_PREFIX .. msg) end
end

function M.runOnlyIf(cond, msg)
   -- continue a running test if condition is met, else skip it
   if not cond then error_fmt(2, M.SKIP_PREFIX .. prettystr(msg)) end
end

function M.success()
   -- stops a test with a success
   error_fmt(2, M.SUCCESS_PREFIX)
end

function M.successIf(cond)
   -- stops a test with a success if condition is met
   if cond then error_fmt(2, M.SUCCESS_PREFIX) end
end

------------------------------------------------------------------
--                  Equality assertions
------------------------------------------------------------------

function M.assertEquals(actual, expected, extra_msg_or_nil, doDeepAnalysis)
   if type(actual) == "table" and type(expected) == "table" then
      if not is_table_equals(actual, expected) then
         failure(errorMsgEquality(actual, expected, doDeepAnalysis), extra_msg_or_nil, 2)
      end
   elseif type(actual) ~= type(expected) then
      failure(errorMsgEquality(actual, expected), extra_msg_or_nil, 2)
   elseif actual ~= expected then
      failure(errorMsgEquality(actual, expected), extra_msg_or_nil, 2)
   end
end

function M.almostEquals(actual, expected, margin)
   if type(actual) ~= "number" or type(expected) ~= "number" or type(margin) ~= "number" then
      error_fmt(
         3,
         "almostEquals: must supply only number arguments.\nArguments supplied: %s, %s, %s",
         prettystr(actual),
         prettystr(expected),
         prettystr(margin)
      )
   end
   if margin < 0 then error_fmt(3, "almostEquals: margin must not be negative, current value is " .. margin) end
   return math.abs(expected - actual) <= margin
end

function M.assertAlmostEquals(actual, expected, margin, extra_msg_or_nil)
   -- check that two floats are close by margin
   margin = margin or M.EPS
   if type(margin) ~= "number" then error_fmt(2, "almostEquals: margin must be a number, not %s", prettystr(margin)) end

   if type(actual) == "table" and type(expected) == "table" then
      -- handle almost equals for table
      if not is_table_equals(actual, expected, margin) then
         failure(errorMsgEquality(actual, expected, nil, margin), extra_msg_or_nil, 2)
      end
   elseif type(actual) == "number" and type(expected) == "number" and type(margin) == "number" then
      if not M.almostEquals(actual, expected, margin) then
         if not M.ORDER_ACTUAL_EXPECTED then
            expected, actual = actual, expected
         end
         local delta = math.abs(actual - expected)
         fail_fmt(
            2,
            extra_msg_or_nil,
            "Values are not almost equal\n" .. "Actual: %s, expected: %s, delta %s above margin of %s",
            actual,
            expected,
            delta,
            margin
         )
      end
   else
      error_fmt(
         3,
         "almostEquals: must supply only number or table arguments.\nArguments supplied: %s, %s, %s",
         prettystr(actual),
         prettystr(expected),
         prettystr(margin)
      )
   end
end

function M.assertNotEquals(actual, expected, extra_msg_or_nil)
   if type(actual) ~= type(expected) then return end

   if type(actual) == "table" and type(expected) == "table" then
      if not is_table_equals(actual, expected) then return end
   elseif actual ~= expected then
      return
   end
   fail_fmt(2, extra_msg_or_nil, "Received the not expected value: %s", prettystr(actual))
end

function M.assertNotAlmostEquals(actual, expected, margin, extra_msg_or_nil)
   -- check that two floats are not close by margin
   margin = margin or M.EPS
   if M.almostEquals(actual, expected, margin) then
      if not M.ORDER_ACTUAL_EXPECTED then
         expected, actual = actual, expected
      end
      local delta = math.abs(actual - expected)
      fail_fmt(
         2,
         extra_msg_or_nil,
         "Values are almost equal\nActual: %s, expected: %s" .. ", delta %s below margin of %s",
         actual,
         expected,
         delta,
         margin
      )
   end
end

function M.assertItemsEquals(actual, expected, extra_msg_or_nil)
   -- checks that the items of table expected
   -- are contained in table actual. Warning, this function
   -- is at least O(n^2)
   if not _is_table_items_equals(actual, expected) then
      expected, actual = prettystrPairs(expected, actual)
      fail_fmt(
         2,
         extra_msg_or_nil,
         "Content of the tables are not identical:\nExpected: %s\nActual: %s",
         expected,
         actual
      )
   end
end

------------------------------------------------------------------
--                  String assertion
------------------------------------------------------------------

function M.assertStrContains(str, sub, isPattern, extra_msg_or_nil)
   -- this relies on lua string.find function
   -- a string always contains the empty string
   -- assert( type(str) == 'string', 'Argument 1 of assertStrContains() should be a string.' ) )
   -- assert( type(sub) == 'string', 'Argument 2 of assertStrContains() should be a string.' ) )
   if not string.find(str, sub, 1, not isPattern) then
      sub, str = prettystrPairs(sub, str, "\n")
      fail_fmt(
         2,
         extra_msg_or_nil,
         "Could not find %s %s in string %s",
         isPattern and "pattern" or "substring",
         sub,
         str
      )
   end
end

function M.assertStrIContains(str, sub, extra_msg_or_nil)
   -- this relies on lua string.find function
   -- a string always contains the empty string
   if not string.find(str:lower(), sub:lower(), 1, true) then
      sub, str = prettystrPairs(sub, str, "\n")
      fail_fmt(2, extra_msg_or_nil, "Could not find (case insensitively) substring %s in string %s", sub, str)
   end
end

function M.assertNotStrContains(str, sub, isPattern, extra_msg_or_nil)
   -- this relies on lua string.find function
   -- a string always contains the empty string
   if string.find(str, sub, 1, not isPattern) then
      sub, str = prettystrPairs(sub, str, "\n")
      fail_fmt(
         2,
         extra_msg_or_nil,
         "Found the not expected %s %s in string %s",
         isPattern and "pattern" or "substring",
         sub,
         str
      )
   end
end

function M.assertNotStrIContains(str, sub, extra_msg_or_nil)
   -- this relies on lua string.find function
   -- a string always contains the empty string
   if string.find(str:lower(), sub:lower(), 1, true) then
      sub, str = prettystrPairs(sub, str, "\n")
      fail_fmt(2, extra_msg_or_nil, "Found (case insensitively) the not expected substring %s in string %s", sub, str)
   end
end

function M.assertStrMatches(str, pattern, start, final, extra_msg_or_nil)
   -- Verify a full match for the string
   if not strMatch(str, pattern, start, final) then
      pattern, str = prettystrPairs(pattern, str, "\n")
      fail_fmt(2, extra_msg_or_nil, "Could not match pattern %s with string %s", pattern, str)
   end
end

local function _assertErrorMsgEquals(stripFileAndLine, expectedMsg, func, ...)
   local no_error, error_msg = pcall(func, ...)
   if no_error then
      failure("No error generated when calling function but expected error: " .. M.prettystr(expectedMsg), nil, 3)
   end
   if type(expectedMsg) == "string" and type(error_msg) ~= "string" then
      -- table are converted to string automatically
      error_msg = tostring(error_msg)
   end
   local differ = false
   if stripFileAndLine then
      if error_msg:gsub("^.+:%d+: ", "") ~= expectedMsg then differ = true end
   else
      if error_msg ~= expectedMsg then
         local tr = type(error_msg)
         local te = type(expectedMsg)
         if te == "table" then
            if tr ~= "table" then
               differ = true
            else
               local ok = pcall(M.assertItemsEquals, error_msg, expectedMsg)
               if not ok then differ = true end
            end
         else
            differ = true
         end
      end
   end

   if differ then
      error_msg, expectedMsg = prettystrPairs(error_msg, expectedMsg)
      fail_fmt(3, nil, "Error message expected: %s\nError message received: %s\n", expectedMsg, error_msg)
   end
end

function M.assertErrorMsgEquals(expectedMsg, func, ...)
   -- assert that calling f with the arguments will raise an error
   -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error
   _assertErrorMsgEquals(false, expectedMsg, func, ...)
end

function M.assertErrorMsgContentEquals(expectedMsg, func, ...)
   _assertErrorMsgEquals(true, expectedMsg, func, ...)
end

function M.assertErrorMsgContains(partialMsg, func, ...)
   -- assert that calling f with the arguments will raise an error
   -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error
   local no_error, error_msg = pcall(func, ...)
   if no_error then
      failure(
         "No error generated when calling function but expected error containing: " .. prettystr(partialMsg),
         nil,
         2
      )
   end
   if type(error_msg) ~= "string" then error_msg = tostring(error_msg) end
   if not string.find(error_msg, partialMsg, nil, true) then
      error_msg, partialMsg = prettystrPairs(error_msg, partialMsg)
      fail_fmt(2, nil, "Error message does not contain: %s\nError message received: %s\n", partialMsg, error_msg)
   end
end

function M.assertErrorMsgMatches(expectedMsg, func, ...)
   -- assert that calling f with the arguments will raise an error
   -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error
   local no_error, error_msg = pcall(func, ...)
   if no_error then
      failure('No error generated when calling function but expected error matching: "' .. expectedMsg .. '"', nil, 2)
   end
   if type(error_msg) ~= "string" then error_msg = tostring(error_msg) end
   if not strMatch(error_msg, expectedMsg) then
      expectedMsg, error_msg = prettystrPairs(expectedMsg, error_msg)
      fail_fmt(2, nil, "Error message does not match pattern: %s\nError message received: %s\n", expectedMsg, error_msg)
   end
end

------------------------------------------------------------------
--              Type assertions
------------------------------------------------------------------

function M.assertEvalToTrue(value, extra_msg_or_nil)
   if not value then
      failure("expected: a value evaluating to true, actual: " .. prettystr(value), extra_msg_or_nil, 2)
   end
end

function M.assertEvalToFalse(value, extra_msg_or_nil)
   if value then failure("expected: false or nil, actual: " .. prettystr(value), extra_msg_or_nil, 2) end
end

function M.assertIsTrue(value, extra_msg_or_nil)
   if value ~= true then failure("expected: true, actual: " .. prettystr(value), extra_msg_or_nil, 2) end
end

function M.assertNotIsTrue(value, extra_msg_or_nil)
   if value == true then failure("expected: not true, actual: " .. prettystr(value), extra_msg_or_nil, 2) end
end

function M.assertIsFalse(value, extra_msg_or_nil)
   if value ~= false then failure("expected: false, actual: " .. prettystr(value), extra_msg_or_nil, 2) end
end

function M.assertNotIsFalse(value, extra_msg_or_nil)
   if value == false then failure("expected: not false, actual: " .. prettystr(value), extra_msg_or_nil, 2) end
end

function M.assertIsNil(value, extra_msg_or_nil)
   if value ~= nil then failure("expected: nil, actual: " .. prettystr(value), extra_msg_or_nil, 2) end
end

function M.assertNotIsNil(value, extra_msg_or_nil)
   if value == nil then failure("expected: not nil, actual: nil", extra_msg_or_nil, 2) end
end

--[[
Add type assertion functions to the module table M. Each of these functions
takes a single parameter "value", and checks that its Lua type matches the
expected string (derived from the function name):

M.assertIsXxx(value) -> ensure that type(value) conforms to "xxx"
]]
for _, funcName in ipairs({
   "assertIsNumber",
   "assertIsString",
   "assertIsTable",
   "assertIsBoolean",
   "assertIsFunction",
   "assertIsUserdata",
   "assertIsThread",
}) do
   local typeExpected = funcName:match("^assertIs([A-Z]%a*)$")
   -- Lua type() always returns lowercase, also make sure the match() succeeded
   typeExpected = typeExpected and typeExpected:lower()
      or error("bad function name '" .. funcName .. "' for type assertion")

   M[funcName] = function(value, extra_msg_or_nil)
      if type(value) ~= typeExpected then
         if type(value) == "nil" then
            fail_fmt(
               2,
               extra_msg_or_nil,
               "expected: a %s value, actual: nil",
               typeExpected,
               type(value),
               prettystrPairs(value)
            )
         else
            fail_fmt(
               2,
               extra_msg_or_nil,
               "expected: a %s value, actual: type %s, value %s",
               typeExpected,
               type(value),
               prettystrPairs(value)
            )
         end
      end
   end
end

--[[
Add shortcuts for verifying type of a variable, without failure (luaunit v2 compatibility)
M.isXxx(value) -> returns true if type(value) conforms to "xxx"
]]
for _, typeExpected in ipairs({ "Number", "String", "Table", "Boolean", "Function", "Userdata", "Thread", "Nil" }) do
   local typeExpectedLower = typeExpected:lower()
   local isType = function(value)
      return (type(value) == typeExpectedLower)
   end
   M["is" .. typeExpected] = isType
   M["is_" .. typeExpectedLower] = isType
end

--[[
Add non-type assertion functions to the module table M. Each of these functions
takes a single parameter "value", and checks that its Lua type differs from the
expected string (derived from the function name):

M.assertNotIsXxx(value) -> ensure that type(value) is not "xxx"
]]
for _, funcName in ipairs({
   "assertNotIsNumber",
   "assertNotIsString",
   "assertNotIsTable",
   "assertNotIsBoolean",
   "assertNotIsFunction",
   "assertNotIsUserdata",
   "assertNotIsThread",
}) do
   local typeUnexpected = funcName:match("^assertNotIs([A-Z]%a*)$")
   -- Lua type() always returns lowercase, also make sure the match() succeeded
   typeUnexpected = typeUnexpected and typeUnexpected:lower()
      or error("bad function name '" .. funcName .. "' for type assertion")

   M[funcName] = function(value, extra_msg_or_nil)
      if type(value) == typeUnexpected then
         fail_fmt(
            2,
            extra_msg_or_nil,
            "expected: not a %s type, actual: value %s",
            typeUnexpected,
            prettystrPairs(value)
         )
      end
   end
end

function M.assertIs(actual, expected, extra_msg_or_nil)
   if actual ~= expected then
      if not M.ORDER_ACTUAL_EXPECTED then
         actual, expected = expected, actual
      end
      local old_print_table_ref_in_error_msg = M.PRINT_TABLE_REF_IN_ERROR_MSG
      M.PRINT_TABLE_REF_IN_ERROR_MSG = true
      expected, actual = prettystrPairs(expected, actual, "\n", "")
      M.PRINT_TABLE_REF_IN_ERROR_MSG = old_print_table_ref_in_error_msg
      fail_fmt(
         2,
         extra_msg_or_nil,
         "expected and actual object should not be different\nExpected: %s\nReceived: %s",
         expected,
         actual
      )
   end
end

function M.assertNotIs(actual, expected, extra_msg_or_nil)
   if actual == expected then
      local old_print_table_ref_in_error_msg = M.PRINT_TABLE_REF_IN_ERROR_MSG
      M.PRINT_TABLE_REF_IN_ERROR_MSG = true
      local s_expected
      if not M.ORDER_ACTUAL_EXPECTED then
         s_expected = prettystrPairs(actual)
      else
         s_expected = prettystrPairs(expected)
      end
      M.PRINT_TABLE_REF_IN_ERROR_MSG = old_print_table_ref_in_error_msg
      fail_fmt(2, extra_msg_or_nil, "expected and actual object should be different: %s", s_expected)
   end
end

------------------------------------------------------------------
--              Scientific assertions
------------------------------------------------------------------

function M.assertIsNaN(value, extra_msg_or_nil)
   if type(value) ~= "number" or value == value then
      failure("expected: NaN, actual: " .. prettystr(value), extra_msg_or_nil, 2)
   end
end

function M.assertNotIsNaN(value, extra_msg_or_nil)
   if type(value) == "number" and value ~= value then failure("expected: not NaN, actual: NaN", extra_msg_or_nil, 2) end
end

function M.assertIsInf(value, extra_msg_or_nil)
   if type(value) ~= "number" or math.abs(value) ~= math.huge then
      failure("expected: #Inf, actual: " .. prettystr(value), extra_msg_or_nil, 2)
   end
end

function M.assertIsPlusInf(value, extra_msg_or_nil)
   if type(value) ~= "number" or value ~= math.huge then
      failure("expected: #Inf, actual: " .. prettystr(value), extra_msg_or_nil, 2)
   end
end

function M.assertIsMinusInf(value, extra_msg_or_nil)
   if type(value) ~= "number" or value ~= -math.huge then
      failure("expected: -#Inf, actual: " .. prettystr(value), extra_msg_or_nil, 2)
   end
end

function M.assertNotIsPlusInf(value, extra_msg_or_nil)
   if type(value) == "number" and value == math.huge then
      failure("expected: not #Inf, actual: #Inf", extra_msg_or_nil, 2)
   end
end

function M.assertNotIsMinusInf(value, extra_msg_or_nil)
   if type(value) == "number" and value == -math.huge then
      failure("expected: not -#Inf, actual: -#Inf", extra_msg_or_nil, 2)
   end
end

function M.assertNotIsInf(value, extra_msg_or_nil)
   if type(value) == "number" and math.abs(value) == math.huge then
      failure("expected: not infinity, actual: " .. prettystr(value), extra_msg_or_nil, 2)
   end
end

function M.assertIsPlusZero(value, extra_msg_or_nil)
   if type(value) ~= "number" or value ~= 0 then
      failure("expected: +0.0, actual: " .. prettystr(value), extra_msg_or_nil, 2)
   else
      if 1 / value == -math.huge then
         -- more precise error diagnosis
         failure("expected: +0.0, actual: -0.0", extra_msg_or_nil, 2)
      else
         if 1 / value ~= math.huge then
            -- strange, case should have already been covered
            failure("expected: +0.0, actual: " .. prettystr(value), extra_msg_or_nil, 2)
         end
      end
   end
end

function M.assertIsMinusZero(value, extra_msg_or_nil)
   if type(value) ~= "number" or value ~= 0 then
      failure("expected: -0.0, actual: " .. prettystr(value), extra_msg_or_nil, 2)
   else
      if 1 / value == math.huge then
         -- more precise error diagnosis
         failure("expected: -0.0, actual: +0.0", extra_msg_or_nil, 2)
      else
         if 1 / value ~= -math.huge then
            -- strange, case should have already been covered
            failure("expected: -0.0, actual: " .. prettystr(value), extra_msg_or_nil, 2)
         end
      end
   end
end

function M.assertNotIsPlusZero(value, extra_msg_or_nil)
   if type(value) == "number" and (1 / value == math.huge) then
      failure("expected: not +0.0, actual: +0.0", extra_msg_or_nil, 2)
   end
end

function M.assertNotIsMinusZero(value, extra_msg_or_nil)
   if type(value) == "number" and (1 / value == -math.huge) then
      failure("expected: not -0.0, actual: -0.0", extra_msg_or_nil, 2)
   end
end

function M.assertTableContains(t, expected, extra_msg_or_nil)
   -- checks that table t contains the expected element
   if table_findkeyof(t, expected) == nil then
      t, expected = prettystrPairs(t, expected)
      fail_fmt(2, extra_msg_or_nil, "Table %s does NOT contain the expected element %s", t, expected)
   end
end

function M.assertNotTableContains(t, expected, extra_msg_or_nil)
   -- checks that table t doesn't contain the expected element
   local k = table_findkeyof(t, expected)
   if k ~= nil then
      t, expected = prettystrPairs(t, expected)
      fail_fmt(
         2,
         extra_msg_or_nil,
         "Table %s DOES contain the unwanted element %s (at key %s)",
         t,
         expected,
         prettystr(k)
      )
   end
end

----------------------------------------------------------------
--                     Compatibility layer
----------------------------------------------------------------

-- for compatibility with LuaUnit v2.x
function M.wrapFunctions()
   -- In LuaUnit version <= 2.1 , this function was necessary to include
   -- a test function inside the global test suite. Nowadays, the functions
   -- are simply run directly as part of the test discovery process.
   -- so just do nothing !
   io.stderr:write([[Use of WrapFunctions() is no longer needed.
Just prefix your test function names with "test" or "Test" and they
will be picked up and run by LuaUnit.
]])
end

local list_of_funcs = {
   -- { official function name , alias }

   -- general assertions
   { "assertEquals", "assert_equals" },
   { "assertItemsEquals", "assert_items_equals" },
   { "assertNotEquals", "assert_not_equals" },
   { "assertAlmostEquals", "assert_almost_equals" },
   { "assertNotAlmostEquals", "assert_not_almost_equals" },
   { "assertEvalToTrue", "assert_eval_to_true" },
   { "assertEvalToFalse", "assert_eval_to_false" },
   { "assertStrContains", "assert_str_contains" },
   { "assertStrIContains", "assert_str_icontains" },
   { "assertNotStrContains", "assert_not_str_contains" },
   { "assertNotStrIContains", "assert_not_str_icontains" },
   { "assertStrMatches", "assert_str_matches" },
   { "assertError", "assert_error" },
   { "assertErrorMsgEquals", "assert_error_msg_equals" },
   { "assertErrorMsgContains", "assert_error_msg_contains" },
   { "assertErrorMsgMatches", "assert_error_msg_matches" },
   { "assertErrorMsgContentEquals", "assert_error_msg_content_equals" },
   { "assertIs", "assert_is" },
   { "assertNotIs", "assert_not_is" },
   { "assertTableContains", "assert_table_contains" },
   { "assertNotTableContains", "assert_not_table_contains" },
   { "wrapFunctions", "WrapFunctions" },
   { "wrapFunctions", "wrap_functions" },

   -- type assertions: assertIsXXX -> assert_is_xxx
   { "assertIsNumber", "assert_is_number" },
   { "assertIsString", "assert_is_string" },
   { "assertIsTable", "assert_is_table" },
   { "assertIsBoolean", "assert_is_boolean" },
   { "assertIsNil", "assert_is_nil" },
   { "assertIsTrue", "assert_is_true" },
   { "assertIsFalse", "assert_is_false" },
   { "assertIsNaN", "assert_is_nan" },
   { "assertIsInf", "assert_is_inf" },
   { "assertIsPlusInf", "assert_is_plus_inf" },
   { "assertIsMinusInf", "assert_is_minus_inf" },
   { "assertIsPlusZero", "assert_is_plus_zero" },
   { "assertIsMinusZero", "assert_is_minus_zero" },
   { "assertIsFunction", "assert_is_function" },
   { "assertIsThread", "assert_is_thread" },
   { "assertIsUserdata", "assert_is_userdata" },

   -- type assertions: assertIsXXX -> assertXxx
   { "assertIsNumber", "assertNumber" },
   { "assertIsString", "assertString" },
   { "assertIsTable", "assertTable" },
   { "assertIsBoolean", "assertBoolean" },
   { "assertIsNil", "assertNil" },
   { "assertIsTrue", "assertTrue" },
   { "assertIsFalse", "assertFalse" },
   { "assertIsNaN", "assertNaN" },
   { "assertIsInf", "assertInf" },
   { "assertIsPlusInf", "assertPlusInf" },
   { "assertIsMinusInf", "assertMinusInf" },
   { "assertIsPlusZero", "assertPlusZero" },
   { "assertIsMinusZero", "assertMinusZero" },
   { "assertIsFunction", "assertFunction" },
   { "assertIsThread", "assertThread" },
   { "assertIsUserdata", "assertUserdata" },

   -- type assertions: assertIsXXX -> assert_xxx (luaunit v2 compat)
   { "assertIsNumber", "assert_number" },
   { "assertIsString", "assert_string" },
   { "assertIsTable", "assert_table" },
   { "assertIsBoolean", "assert_boolean" },
   { "assertIsNil", "assert_nil" },
   { "assertIsTrue", "assert_true" },
   { "assertIsFalse", "assert_false" },
   { "assertIsNaN", "assert_nan" },
   { "assertIsInf", "assert_inf" },
   { "assertIsPlusInf", "assert_plus_inf" },
   { "assertIsMinusInf", "assert_minus_inf" },
   { "assertIsPlusZero", "assert_plus_zero" },
   { "assertIsMinusZero", "assert_minus_zero" },
   { "assertIsFunction", "assert_function" },
   { "assertIsThread", "assert_thread" },
   { "assertIsUserdata", "assert_userdata" },

   -- type assertions: assertNotIsXXX -> assert_not_is_xxx
   { "assertNotIsNumber", "assert_not_is_number" },
   { "assertNotIsString", "assert_not_is_string" },
   { "assertNotIsTable", "assert_not_is_table" },
   { "assertNotIsBoolean", "assert_not_is_boolean" },
   { "assertNotIsNil", "assert_not_is_nil" },
   { "assertNotIsTrue", "assert_not_is_true" },
   { "assertNotIsFalse", "assert_not_is_false" },
   { "assertNotIsNaN", "assert_not_is_nan" },
   { "assertNotIsInf", "assert_not_is_inf" },
   { "assertNotIsPlusInf", "assert_not_plus_inf" },
   { "assertNotIsMinusInf", "assert_not_minus_inf" },
   { "assertNotIsPlusZero", "assert_not_plus_zero" },
   { "assertNotIsMinusZero", "assert_not_minus_zero" },
   { "assertNotIsFunction", "assert_not_is_function" },
   { "assertNotIsThread", "assert_not_is_thread" },
   { "assertNotIsUserdata", "assert_not_is_userdata" },

   -- type assertions: assertNotIsXXX -> assertNotXxx (luaunit v2 compat)
   { "assertNotIsNumber", "assertNotNumber" },
   { "assertNotIsString", "assertNotString" },
   { "assertNotIsTable", "assertNotTable" },
   { "assertNotIsBoolean", "assertNotBoolean" },
   { "assertNotIsNil", "assertNotNil" },
   { "assertNotIsTrue", "assertNotTrue" },
   { "assertNotIsFalse", "assertNotFalse" },
   { "assertNotIsNaN", "assertNotNaN" },
   { "assertNotIsInf", "assertNotInf" },
   { "assertNotIsPlusInf", "assertNotPlusInf" },
   { "assertNotIsMinusInf", "assertNotMinusInf" },
   { "assertNotIsPlusZero", "assertNotPlusZero" },
   { "assertNotIsMinusZero", "assertNotMinusZero" },
   { "assertNotIsFunction", "assertNotFunction" },
   { "assertNotIsThread", "assertNotThread" },
   { "assertNotIsUserdata", "assertNotUserdata" },

   -- type assertions: assertNotIsXXX -> assert_not_xxx
   { "assertNotIsNumber", "assert_not_number" },
   { "assertNotIsString", "assert_not_string" },
   { "assertNotIsTable", "assert_not_table" },
   { "assertNotIsBoolean", "assert_not_boolean" },
   { "assertNotIsNil", "assert_not_nil" },
   { "assertNotIsTrue", "assert_not_true" },
   { "assertNotIsFalse", "assert_not_false" },
   { "assertNotIsNaN", "assert_not_nan" },
   { "assertNotIsInf", "assert_not_inf" },
   { "assertNotIsPlusInf", "assert_not_plus_inf" },
   { "assertNotIsMinusInf", "assert_not_minus_inf" },
   { "assertNotIsPlusZero", "assert_not_plus_zero" },
   { "assertNotIsMinusZero", "assert_not_minus_zero" },
   { "assertNotIsFunction", "assert_not_function" },
   { "assertNotIsThread", "assert_not_thread" },
   { "assertNotIsUserdata", "assert_not_userdata" },

   -- all assertions with Coroutine duplicate Thread assertions
   { "assertIsThread", "assertIsCoroutine" },
   { "assertIsThread", "assertCoroutine" },
   { "assertIsThread", "assert_is_coroutine" },
   { "assertIsThread", "assert_coroutine" },
   { "assertNotIsThread", "assertNotIsCoroutine" },
   { "assertNotIsThread", "assertNotCoroutine" },
   { "assertNotIsThread", "assert_not_is_coroutine" },
   { "assertNotIsThread", "assert_not_coroutine" },
}

-- Create all aliases in M
for _, v in ipairs(list_of_funcs) do
   local funcname, alias = v[1], v[2]
   M[alias] = M[funcname]

   if EXPORT_ASSERT_TO_GLOBALS then
      _G[funcname] = M[funcname]
      _G[alias] = M[funcname]
   end
end

----------------------------------------------------------------
--
--                     Outputters
--
----------------------------------------------------------------

-- A common "base" class for outputters
-- For concepts involved (class inheritance) see http://www.lua.org/pil/16.2.html

local genericOutput = { __class__ = "genericOutput" } -- class
local genericOutput_MT = { __index = genericOutput } -- metatable
M.genericOutput = genericOutput -- publish, so that custom classes may derive from it

function genericOutput.new(runner, default_verbosity)
   -- runner is the "parent" object controlling the output, usually a LuaUnit instance
   local t = { runner = runner }
   if runner then
      t.result = runner.result
      t.verbosity = runner.verbosity or default_verbosity
      t.fname = runner.fname
   else
      t.verbosity = default_verbosity
   end
   return setmetatable(t, genericOutput_MT)
end

-- abstract ("empty") methods
function genericOutput:startSuite()
   -- Called once, when the suite is started
end

function genericOutput:startClass(className)
   -- Called each time a new test class is started
end

function genericOutput:startTest(testName)
   -- called each time a new test is started, right before the setUp()
   -- the current test status node is already created and available in: self.result.currentNode
end

function genericOutput:updateStatus(node)
   -- called with status failed or error as soon as the error/failure is encountered
   -- this method is NOT called for a successful test because a test is marked as successful by default
   -- and does not need to be updated
end

function genericOutput:endTest(node)
   -- called when the test is finished, after the tearDown() method
end

function genericOutput:endClass()
   -- called when executing the class is finished, before moving on to the next class of at the end of the test execution
end

function genericOutput:endSuite()
   -- called at the end of the test suite execution
end

----------------------------------------------------------------
--                     class TapOutput
----------------------------------------------------------------

local TapOutput = genericOutput.new() -- derived class
local TapOutput_MT = { __index = TapOutput } -- metatable
TapOutput.__class__ = "TapOutput"

-- For a good reference for TAP format, check: http://testanything.org/tap-specification.html

function TapOutput.new(runner)
   local t = genericOutput.new(runner, M.VERBOSITY_LOW)
   return setmetatable(t, TapOutput_MT)
end
function TapOutput:startSuite()
   print("1.." .. self.result.selectedCount)
   print("# Started on " .. self.result.startDate)
end
function TapOutput:startClass(className)
   if className ~= "[TestFunctions]" then print("# Starting class: " .. className) end
end

function TapOutput:updateStatus(node)
   if node:isSkipped() then
      io.stdout:write("ok ", self.result.currentTestNumber, "\t# SKIP ", node.msg, "\n")
      return
   end

   io.stdout:write("not ok ", self.result.currentTestNumber, "\t", node.testName, "\n")
   if self.verbosity > M.VERBOSITY_LOW then print(prefixString("#   ", node.msg)) end
   if (node:isFailure() or node:isError()) and self.verbosity > M.VERBOSITY_DEFAULT then
      print(prefixString("#   ", node.stackTrace))
   end
end

function TapOutput:endTest(node)
   if node:isSuccess() then io.stdout:write("ok     ", self.result.currentTestNumber, "\t", node.testName, "\n") end
end

function TapOutput:endSuite()
   print("# " .. M.LuaUnit.statusLine(self.result))
   return self.result.notSuccessCount
end

-- class TapOutput end

----------------------------------------------------------------
--                     class JUnitOutput
----------------------------------------------------------------

-- See directory junitxml for more information about the junit format
local JUnitOutput = genericOutput.new() -- derived class
local JUnitOutput_MT = { __index = JUnitOutput } -- metatable
JUnitOutput.__class__ = "JUnitOutput"

function JUnitOutput.new(runner)
   local t = genericOutput.new(runner, M.VERBOSITY_LOW)
   t.testList = {}
   return setmetatable(t, JUnitOutput_MT)
end

function JUnitOutput:startSuite()
   -- open xml file early to deal with errors
   if self.fname == nil then error("With Junit, an output filename must be supplied with --name!") end
   if string.sub(self.fname, -4) ~= ".xml" then self.fname = self.fname .. ".xml" end
   self.fd = io.open(self.fname, "w")
   if self.fd == nil then error("Could not open file for writing: " .. self.fname) end

   print("# XML output to " .. self.fname)
   print("# Started on " .. self.result.startDate)
end
function JUnitOutput:startClass(className)
   if className ~= "[TestFunctions]" then print("# Starting class: " .. className) end
end
function JUnitOutput:startTest(testName)
   print("# Starting test: " .. testName)
end

function JUnitOutput:updateStatus(node)
   if node:isFailure() then
      print("#   Failure: " .. prefixString("#   ", node.msg):sub(4, nil))
      -- print('# ' .. node.stackTrace)
   elseif node:isError() then
      print("#   Error: " .. prefixString("#   ", node.msg):sub(4, nil))
      -- print('# ' .. node.stackTrace)
   end
end

function JUnitOutput:endSuite()
   print("# " .. M.LuaUnit.statusLine(self.result))

   -- XML file writing
   self.fd:write('<?xml version="1.0" encoding="UTF-8" ?>\n')
   self.fd:write("<testsuites>\n")
   self.fd:write(
      string.format(
         '    <testsuite name="LuaUnit" id="00001" package="" hostname="localhost" tests="%d" timestamp="%s" time="%0.3f" errors="%d" failures="%d" skipped="%d">\n',
         self.result.runCount,
         self.result.startIsodate,
         self.result.duration,
         self.result.errorCount,
         self.result.failureCount,
         self.result.skippedCount
      )
   )
   self.fd:write("        <properties>\n")
   self.fd:write(string.format('            <property name="Lua Version" value="%s"/>\n', _VERSION))
   self.fd:write(string.format('            <property name="LuaUnit Version" value="%s"/>\n', M.VERSION))
   -- XXX please include system name and version if possible
   self.fd:write("        </properties>\n")

   for i, node in ipairs(self.result.allTests) do
      self.fd:write(
         string.format(
            '        <testcase classname="%s" name="%s" time="%0.3f">\n',
            node.className,
            node.testName,
            node.duration
         )
      )
      if node:isNotSuccess() then self.fd:write(node:statusXML()) end
      self.fd:write("        </testcase>\n")
   end

   -- Next two lines are needed to validate junit ANT xsd, but really not useful in general:
   self.fd:write("    <system-out/>\n")
   self.fd:write("    <system-err/>\n")

   self.fd:write("    </testsuite>\n")
   self.fd:write("</testsuites>\n")
   self.fd:close()
   return self.result.notSuccessCount
end

-- class TapOutput end

----------------------------------------------------------------
--                     class TextOutput
----------------------------------------------------------------

--[[    Example of other unit-tests suite text output

-- Python Non verbose:

For each test: . or F or E

If some failed tests:
    ==============
    ERROR / FAILURE: TestName (testfile.testclass)
    ---------
    Stack trace


then --------------
then "Ran x tests in 0.000s"
then OK or FAILED (failures=1, error=1)

-- Python Verbose:
testname (filename.classname) ... ok
testname (filename.classname) ... FAIL
testname (filename.classname) ... ERROR

then --------------
then "Ran x tests in 0.000s"
then OK or FAILED (failures=1, error=1)

-- Ruby:
Started
 .
 Finished in 0.002695 seconds.

 1 tests, 2 assertions, 0 failures, 0 errors

-- Ruby:
>> ruby tc_simple_number2.rb
Loaded suite tc_simple_number2
Started
F..
Finished in 0.038617 seconds.

  1) Failure:
test_failure(TestSimpleNumber) [tc_simple_number2.rb:16]:
Adding doesn't work.
<3> expected but was
<4>.

3 tests, 4 assertions, 1 failures, 0 errors

-- Java Junit
.......F.
Time: 0,003
There was 1 failure:
1) testCapacity(junit.samples.VectorTest)junit.framework.AssertionFailedError
    at junit.samples.VectorTest.testCapacity(VectorTest.java:87)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

FAILURES!!!
Tests run: 8,  Failures: 1,  Errors: 0


-- Maven

# mvn test
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running math.AdditionTest
Tests run: 2, Failures: 1, Errors: 0, Skipped: 0, Time elapsed:
0.03 sec <<< FAILURE!

Results :

Failed tests:
  testLireSymbole(math.AdditionTest)

Tests run: 2, Failures: 1, Errors: 0, Skipped: 0


-- LuaUnit
---- non verbose
* display . or F or E when running tests
---- verbose
* display test name + ok/fail
----
* blank line
* number) ERROR or FAILURE: TestName
   Stack trace
* blank line
* number) ERROR or FAILURE: TestName
   Stack trace

then --------------
then "Ran x tests in 0.000s (%d not selected, %d skipped)"
then OK or FAILED (failures=1, error=1)


]]

local TextOutput = genericOutput.new() -- derived class
local TextOutput_MT = { __index = TextOutput } -- metatable
TextOutput.__class__ = "TextOutput"

function TextOutput.new(runner)
   local t = genericOutput.new(runner, M.VERBOSITY_DEFAULT)
   t.errorList = {}
   return setmetatable(t, TextOutput_MT)
end

function TextOutput:startSuite()
   if self.verbosity > M.VERBOSITY_DEFAULT then print("Started on " .. self.result.startDate) end
end

function TextOutput:startTest(testName)
   if self.verbosity > M.VERBOSITY_DEFAULT then io.stdout:write("    ", self.result.currentNode.testName, " ... ") end
end

function TextOutput:endTest(node)
   if node:isSuccess() then
      if self.verbosity > M.VERBOSITY_DEFAULT then
         io.stdout:write("Ok\n")
      else
         io.stdout:write(".")
         io.stdout:flush()
      end
   else
      if self.verbosity > M.VERBOSITY_DEFAULT then
         print(node.status)
         print(node.msg)
         --[[
                -- find out when to do this:
                if self.verbosity > M.VERBOSITY_DEFAULT then
                    print( node.stackTrace )
                end
                ]]
      else
         -- write only the first character of status E, F or S
         io.stdout:write(string.sub(node.status, 1, 1))
         io.stdout:flush()
      end
   end
end

function TextOutput:displayOneFailedTest(index, fail)
   print(index .. ") " .. fail.testName)
   print(fail.msg)
   print(fail.stackTrace)
   print()
end

function TextOutput:displayErroredTests()
   if #self.result.errorTests ~= 0 then
      print("Tests with errors:")
      print("------------------")
      for i, v in ipairs(self.result.errorTests) do
         self:displayOneFailedTest(i, v)
      end
   end
end

function TextOutput:displayFailedTests()
   if #self.result.failedTests ~= 0 then
      print("Failed tests:")
      print("-------------")
      for i, v in ipairs(self.result.failedTests) do
         self:displayOneFailedTest(i, v)
      end
   end
end

function TextOutput:endSuite()
   if self.verbosity > M.VERBOSITY_DEFAULT then
      print("=========================================================")
   else
      print()
   end
   self:displayErroredTests()
   self:displayFailedTests()
   print(M.LuaUnit.statusLine(self.result))
   if self.result.notSuccessCount == 0 then print("OK") end
end

-- class TextOutput end

----------------------------------------------------------------
--                     class NilOutput
----------------------------------------------------------------

local function nopCallable()
   --print(42)
   return nopCallable
end

local NilOutput = { __class__ = "NilOuptut" } -- class
local NilOutput_MT = { __index = nopCallable } -- metatable

function NilOutput.new(runner)
   return setmetatable({ __class__ = "NilOutput" }, NilOutput_MT)
end

----------------------------------------------------------------
--
--                     class LuaUnit
--
----------------------------------------------------------------

M.LuaUnit = {
   outputType = TextOutput,
   verbosity = M.VERBOSITY_DEFAULT,
   __class__ = "LuaUnit",
   instances = {},
}
local LuaUnit_MT = { __index = M.LuaUnit }

if EXPORT_ASSERT_TO_GLOBALS then LuaUnit = M.LuaUnit end

function M.LuaUnit.new()
   local newInstance = setmetatable({}, LuaUnit_MT)
   return newInstance
end

-----------------[[ Utility methods ]]---------------------

function M.LuaUnit.asFunction(aObject)
   -- return "aObject" if it is a function, and nil otherwise
   if "function" == type(aObject) then return aObject end
end

function M.LuaUnit.splitClassMethod(someName)
   --[[
        Return a pair of className, methodName strings for a name in the form
        "class.method". If no class part (or separator) is found, will return
        nil, someName instead (the latter being unchanged).

        This convention thus also replaces the older isClassMethod() test:
        You just have to check for a non-nil className (return) value.
        ]]
   local separator = string.find(someName, ".", 1, true)
   if separator then return someName:sub(1, separator - 1), someName:sub(separator + 1) end
   return nil, someName
end

function M.LuaUnit.isMethodTestName(s)
   -- return true is the name matches the name of a test method
   -- default rule is that is starts with 'Test' or with 'test'
   return string.sub(s, 1, 4):lower() == "test"
end

function M.LuaUnit.isTestName(s)
   -- return true is the name matches the name of a test
   -- default rule is that is starts with 'Test' or with 'test'
   return string.sub(s, 1, 4):lower() == "test"
end

function M.LuaUnit.collectTests()
   -- return a list of all test names in the global namespace
   -- that match LuaUnit.isTestName

   local testNames = {}
   for k, _ in pairs(_G) do
      if type(k) == "string" and M.LuaUnit.isTestName(k) then table.insert(testNames, k) end
   end
   table.sort(testNames)
   return testNames
end

function M.LuaUnit.parseCmdLine(cmdLine)
   -- parse the command line
   -- Supported command line parameters:
   -- --verbose, -v: increase verbosity
   -- --quiet, -q: silence output
   -- --error, -e: treat errors as fatal (quit program)
   -- --output, -o, + name: select output type
   -- --pattern, -p, + pattern: run test matching pattern, may be repeated
   -- --exclude, -x, + pattern: run test not matching pattern, may be repeated
   -- --shuffle, -s, : shuffle tests before reunning them
   -- --name, -n, + fname: name of output file for junit, default to stdout
   -- --repeat, -r, + num: number of times to execute each test
   -- [testnames, ...]: run selected test names
   --
   -- Returns a table with the following fields:
   -- verbosity: nil, M.VERBOSITY_DEFAULT, M.VERBOSITY_QUIET, M.VERBOSITY_VERBOSE
   -- output: nil, 'tap', 'junit', 'text', 'nil'
   -- testNames: nil or a list of test names to run
   -- exeRepeat: num or 1
   -- pattern: nil or a list of patterns
   -- exclude: nil or a list of patterns

   local result, state = {}, nil
   local SET_OUTPUT = 1
   local SET_PATTERN = 2
   local SET_EXCLUDE = 3
   local SET_FNAME = 4
   local SET_REPEAT = 5

   if cmdLine == nil then return result end

   local function parseOption(option)
      if option == "--help" or option == "-h" then
         result["help"] = true
         return
      elseif option == "--version" then
         result["version"] = true
         return
      elseif option == "--verbose" or option == "-v" then
         result["verbosity"] = M.VERBOSITY_VERBOSE
         return
      elseif option == "--quiet" or option == "-q" then
         result["verbosity"] = M.VERBOSITY_QUIET
         return
      elseif option == "--error" or option == "-e" then
         result["quitOnError"] = true
         return
      elseif option == "--failure" or option == "-f" then
         result["quitOnFailure"] = true
         return
      elseif option == "--shuffle" or option == "-s" then
         result["shuffle"] = true
         return
      elseif option == "--output" or option == "-o" then
         state = SET_OUTPUT
         return state
      elseif option == "--name" or option == "-n" then
         state = SET_FNAME
         return state
      elseif option == "--repeat" or option == "-r" then
         state = SET_REPEAT
         return state
      elseif option == "--pattern" or option == "-p" then
         state = SET_PATTERN
         return state
      elseif option == "--exclude" or option == "-x" then
         state = SET_EXCLUDE
         return state
      end
      error("Unknown option: " .. option, 3)
   end

   local function setArg(cmdArg, state)
      if state == SET_OUTPUT then
         result["output"] = cmdArg
         return
      elseif state == SET_FNAME then
         result["fname"] = cmdArg
         return
      elseif state == SET_REPEAT then
         result["exeRepeat"] = tonumber(cmdArg) or error("Malformed -r argument: " .. cmdArg)
         return
      elseif state == SET_PATTERN then
         if result["pattern"] then
            table.insert(result["pattern"], cmdArg)
         else
            result["pattern"] = { cmdArg }
         end
         return
      elseif state == SET_EXCLUDE then
         local notArg = "!" .. cmdArg
         if result["pattern"] then
            table.insert(result["pattern"], notArg)
         else
            result["pattern"] = { notArg }
         end
         return
      end
      error("Unknown parse state: " .. state)
   end

   for i, cmdArg in ipairs(cmdLine) do
      if state ~= nil then
         setArg(cmdArg, state, result)
         state = nil
      else
         if cmdArg:sub(1, 1) == "-" then
            state = parseOption(cmdArg)
         else
            if result["testNames"] then
               table.insert(result["testNames"], cmdArg)
            else
               result["testNames"] = { cmdArg }
            end
         end
      end
   end

   if result["help"] then M.LuaUnit.help() end

   if result["version"] then M.LuaUnit.version() end

   if state ~= nil then error("Missing argument after " .. cmdLine[#cmdLine], 2) end

   return result
end

function M.LuaUnit.help()
   print(M.USAGE)
   os.exit(0)
end

function M.LuaUnit.version()
   print("LuaUnit v" .. M.VERSION .. " by Philippe Fremy <phil@freehackers.org>")
   os.exit(0)
end

----------------------------------------------------------------
--                     class NodeStatus
----------------------------------------------------------------

local NodeStatus = { __class__ = "NodeStatus" } -- class
local NodeStatus_MT = { __index = NodeStatus } -- metatable
M.NodeStatus = NodeStatus

-- values of status
NodeStatus.SUCCESS = "SUCCESS"
NodeStatus.SKIP = "SKIP"
NodeStatus.FAIL = "FAIL"
NodeStatus.ERROR = "ERROR"

function NodeStatus.new(number, testName, className)
   -- default constructor, test are PASS by default
   local t = { number = number, testName = testName, className = className }
   setmetatable(t, NodeStatus_MT)
   t:success()
   return t
end

function NodeStatus:success()
   self.status = self.SUCCESS
   -- useless because lua does this for us, but it helps me remembering the relevant field names
   self.msg = nil
   self.stackTrace = nil
end

function NodeStatus:skip(msg)
   self.status = self.SKIP
   self.msg = msg
   self.stackTrace = nil
end

function NodeStatus:fail(msg, stackTrace)
   self.status = self.FAIL
   self.msg = msg
   self.stackTrace = stackTrace
end

function NodeStatus:error(msg, stackTrace)
   self.status = self.ERROR
   self.msg = msg
   self.stackTrace = stackTrace
end

function NodeStatus:isSuccess()
   return self.status == NodeStatus.SUCCESS
end

function NodeStatus:isNotSuccess()
   -- Return true if node is either failure or error or skip
   return (self.status == NodeStatus.FAIL or self.status == NodeStatus.ERROR or self.status == NodeStatus.SKIP)
end

function NodeStatus:isSkipped()
   return self.status == NodeStatus.SKIP
end

function NodeStatus:isFailure()
   return self.status == NodeStatus.FAIL
end

function NodeStatus:isError()
   return self.status == NodeStatus.ERROR
end

function NodeStatus:statusXML()
   if self:isError() then
      return table.concat({
         '            <error type="',
         xmlEscape(self.msg),
         '">\n',
         "                <![CDATA[",
         xmlCDataEscape(self.stackTrace),
         "]]></error>\n",
      })
   elseif self:isFailure() then
      return table.concat({
         '            <failure type="',
         xmlEscape(self.msg),
         '">\n',
         "                <![CDATA[",
         xmlCDataEscape(self.stackTrace),
         "]]></failure>\n",
      })
   elseif self:isSkipped() then
      return table.concat({ "            <skipped>", xmlEscape(self.msg), "</skipped>\n" })
   end
   return "            <passed/>\n" -- (not XSD-compliant! normally shouldn't get here)
end

--------------[[ Output methods ]]-------------------------

local function conditional_plural(number, singular)
   -- returns a grammatically well-formed string "%d <singular/plural>"
   local suffix = ""
   if number ~= 1 then -- use plural
      suffix = (singular:sub(-2) == "ss") and "es" or "s"
   end
   return string.format("%d %s%s", number, singular, suffix)
end

function M.LuaUnit.statusLine(result)
   -- return status line string according to results
   local s = {
      string.format("Ran %d tests in %0.3f seconds", result.runCount, result.duration),
      conditional_plural(result.successCount, "success"),
   }
   if result.notSuccessCount > 0 then
      if result.failureCount > 0 then table.insert(s, conditional_plural(result.failureCount, "failure")) end
      if result.errorCount > 0 then table.insert(s, conditional_plural(result.errorCount, "error")) end
   else
      table.insert(s, "0 failures")
   end
   if result.skippedCount > 0 then table.insert(s, string.format("%d skipped", result.skippedCount)) end
   if result.nonSelectedCount > 0 then table.insert(s, string.format("%d non-selected", result.nonSelectedCount)) end
   return table.concat(s, ", ")
end

function M.LuaUnit:startSuite(selectedCount, nonSelectedCount)
   self.result = {
      selectedCount = selectedCount,
      nonSelectedCount = nonSelectedCount,
      successCount = 0,
      runCount = 0,
      currentTestNumber = 0,
      currentClassName = "",
      currentNode = nil,
      suiteStarted = true,
      startTime = os.clock(),
      startDate = os.date(os.getenv("LUAUNIT_DATEFMT")),
      startIsodate = os.date("%Y-%m-%dT%H:%M:%S"),
      patternIncludeFilter = self.patternIncludeFilter,

      -- list of test node status
      allTests = {},
      failedTests = {},
      errorTests = {},
      skippedTests = {},

      failureCount = 0,
      errorCount = 0,
      notSuccessCount = 0,
      skippedCount = 0,
   }

   self.outputType = self.outputType or TextOutput
   self.output = self.outputType.new(self)
   self.output:startSuite()
end

function M.LuaUnit:startClass(className, classInstance)
   self.result.currentClassName = className
   self.output:startClass(className)
   self:setupClass(className, classInstance)
end

function M.LuaUnit:startTest(testName)
   self.result.currentTestNumber = self.result.currentTestNumber + 1
   self.result.runCount = self.result.runCount + 1
   self.result.currentNode = NodeStatus.new(self.result.currentTestNumber, testName, self.result.currentClassName)
   self.result.currentNode.startTime = os.clock()
   table.insert(self.result.allTests, self.result.currentNode)
   self.output:startTest(testName)
end

function M.LuaUnit:updateStatus(err)
   -- "err" is expected to be a table / result from protectedCall()
   if err.status == NodeStatus.SUCCESS then return end

   local node = self.result.currentNode

   --[[ As a first approach, we will report only one error or one failure for one test.

        However, we can have the case where the test is in failure, and the teardown is in error.
        In such case, it's a good idea to report both a failure and an error in the test suite. This is
        what Python unittest does for example. However, it mixes up counts so need to be handled carefully: for
        example, there could be more (failures + errors) count that tests. What happens to the current node ?

        We will do this more intelligent version later.
        ]]

   -- if the node is already in failure/error, just don't report the new error (see above)
   if node.status ~= NodeStatus.SUCCESS then return end

   if err.status == NodeStatus.FAIL then
      node:fail(err.msg, err.trace)
      table.insert(self.result.failedTests, node)
   elseif err.status == NodeStatus.ERROR then
      node:error(err.msg, err.trace)
      table.insert(self.result.errorTests, node)
   elseif err.status == NodeStatus.SKIP then
      node:skip(err.msg)
      table.insert(self.result.skippedTests, node)
   else
      error("No such status: " .. prettystr(err.status))
   end

   self.output:updateStatus(node)
end

function M.LuaUnit:endTest()
   local node = self.result.currentNode
   -- print( 'endTest() '..prettystr(node))
   -- print( 'endTest() '..prettystr(node:isNotSuccess()))
   node.duration = os.clock() - node.startTime
   node.startTime = nil
   self.output:endTest(node)

   if node:isSuccess() then
      self.result.successCount = self.result.successCount + 1
   elseif node:isError() then
      if self.quitOnError or self.quitOnFailure then
         -- Runtime error - abort test execution as requested by
         -- "--error" option. This is done by setting a special
         -- flag that gets handled in internalRunSuiteByInstances().
         print("\nERROR during LuaUnit test execution:\n" .. node.msg)
         self.result.aborted = true
      end
   elseif node:isFailure() then
      if self.quitOnFailure then
         -- Failure - abort test execution as requested by
         -- "--failure" option. This is done by setting a special
         -- flag that gets handled in internalRunSuiteByInstances().
         print("\nFailure during LuaUnit test execution:\n" .. node.msg)
         self.result.aborted = true
      end
   elseif node:isSkipped() then
      self.result.runCount = self.result.runCount - 1
   else
      error("No such node status: " .. prettystr(node.status))
   end
   self.result.currentNode = nil
end

function M.LuaUnit:endClass()
   self:teardownClass(self.lastClassName, self.lastClassInstance)
   self.output:endClass()
end

function M.LuaUnit:endSuite()
   if self.result.suiteStarted == false then error("LuaUnit:endSuite() -- suite was already ended") end
   self.result.duration = os.clock() - self.result.startTime
   self.result.suiteStarted = false

   -- Expose test counts for outputter's endSuite(). This could be managed
   -- internally instead by using the length of the lists of failed tests
   -- but unit tests rely on these fields being present.
   self.result.failureCount = #self.result.failedTests
   self.result.errorCount = #self.result.errorTests
   self.result.notSuccessCount = self.result.failureCount + self.result.errorCount
   self.result.skippedCount = #self.result.skippedTests

   self.output:endSuite()
end

function M.LuaUnit:setOutputType(outputType, fname)
   -- Configures LuaUnit runner output
   -- outputType is one of: NIL, TAP, JUNIT, TEXT
   -- when outputType is junit, the additional argument fname is used to set the name of junit output file
   -- for other formats, fname is ignored
   if outputType:upper() == "NIL" then
      self.outputType = NilOutput
      return
   end
   if outputType:upper() == "TAP" then
      self.outputType = TapOutput
      return
   end
   if outputType:upper() == "JUNIT" then
      self.outputType = JUnitOutput
      if fname then self.fname = fname end
      return
   end
   if outputType:upper() == "TEXT" then
      self.outputType = TextOutput
      return
   end
   error("No such format: " .. outputType, 2)
end

--------------[[ Runner ]]-----------------

function M.LuaUnit:protectedCall(classInstance, methodInstance, prettyFuncName)
   -- if classInstance is nil, this is just a function call
   -- else, it's method of a class being called.

   local function err_handler(e)
      -- transform error into a table, adding the traceback information
      return {
         status = NodeStatus.ERROR,
         msg = e,
         trace = string.sub(debug.traceback("", 1), 2),
      }
   end

   local ok, err
   if classInstance then
      -- stupid Lua < 5.2 does not allow xpcall with arguments so let's use a workaround
      ok, err = xpcall(function()
         methodInstance(classInstance)
      end, err_handler)
   else
      ok, err = xpcall(function()
         methodInstance()
      end, err_handler)
   end
   if ok then return { status = NodeStatus.SUCCESS } end
   -- print('ok="'..prettystr(ok)..'" err="'..prettystr(err)..'"')

   local iter_msg
   iter_msg = self.exeRepeat and "iteration " .. self.currentCount

   err.msg, err.status = M.adjust_err_msg_with_iter(err.msg, iter_msg)

   if err.status == NodeStatus.SUCCESS or err.status == NodeStatus.SKIP then
      err.trace = nil
      return err
   end

   -- reformat / improve the stack trace
   if prettyFuncName then -- we do have the real method name
      err.trace = err.trace:gsub("in (%a+) 'methodInstance'", "in %1 '" .. prettyFuncName .. "'")
   end
   if STRIP_LUAUNIT_FROM_STACKTRACE then err.trace = stripLuaunitTrace2(err.trace, err.msg) end

   return err -- return the error "object" (table)
end

function M.LuaUnit:execOneFunction(className, methodName, classInstance, methodInstance)
   -- When executing a test function, className and classInstance must be nil
   -- When executing a class method, all parameters must be set

   if type(methodInstance) ~= "function" then
      self:unregisterSuite()
      error(tostring(methodName) .. " must be a function, not " .. type(methodInstance))
   end

   local prettyFuncName
   if className == nil then
      className = "[TestFunctions]"
      prettyFuncName = methodName
   else
      prettyFuncName = className .. "." .. methodName
   end

   if self.lastClassName ~= className then
      if self.lastClassName ~= nil then self:endClass() end
      self:startClass(className, classInstance)
      self.lastClassName = className
      self.lastClassInstance = classInstance
   end

   self:startTest(prettyFuncName)

   local node = self.result.currentNode
   for iter_n = 1, self.exeRepeat or 1 do
      if node:isNotSuccess() then break end
      self.currentCount = iter_n

      -- run setUp first (if any)
      if classInstance then
         local func = self.asFunction(classInstance.setUp)
            or self.asFunction(classInstance.Setup)
            or self.asFunction(classInstance.setup)
            or self.asFunction(classInstance.SetUp)
         if func then self:updateStatus(self:protectedCall(classInstance, func, className .. ".setUp")) end
      end

      -- run testMethod()
      if node:isSuccess() then self:updateStatus(self:protectedCall(classInstance, methodInstance, prettyFuncName)) end

      -- lastly, run tearDown (if any)
      if classInstance then
         local func = self.asFunction(classInstance.tearDown)
            or self.asFunction(classInstance.TearDown)
            or self.asFunction(classInstance.teardown)
            or self.asFunction(classInstance.Teardown)
         if func then self:updateStatus(self:protectedCall(classInstance, func, className .. ".tearDown")) end
      end
   end

   self:endTest()
end

function M.LuaUnit.expandOneClass(result, className, classInstance)
   --[[
        Input: a list of { name, instance }, a class name, a class instance
        Ouptut: modify result to add all test method instance in the form:
        { className.methodName, classInstance }
        ]]
   for methodName, methodInstance in sortedPairs(classInstance) do
      if M.LuaUnit.asFunction(methodInstance) and M.LuaUnit.isMethodTestName(methodName) then
         table.insert(result, { className .. "." .. methodName, classInstance })
      end
   end
end

function M.LuaUnit.expandClasses(listOfNameAndInst)
   --[[
        -- expand all classes (provided as {className, classInstance}) to a list of {className.methodName, classInstance}
        -- functions and methods remain untouched

        Input: a list of { name, instance }

        Output:
        * { function name, function instance } : do nothing
        * { class.method name, class instance }: do nothing
        * { class name, class instance } : add all method names in the form of (className.methodName, classInstance)
        ]]
   local result = {}

   for i, v in ipairs(listOfNameAndInst) do
      local name, instance = v[1], v[2]
      if M.LuaUnit.asFunction(instance) then
         table.insert(result, { name, instance })
      else
         if type(instance) ~= "table" then
            error(
               "Instance must be a table or a function, not a "
                  .. type(instance)
                  .. " with value "
                  .. prettystr(instance)
            )
         end
         local className, methodName = M.LuaUnit.splitClassMethod(name)
         if className then
            local methodInstance = instance[methodName]
            if methodInstance == nil then
               error("Could not find method in class " .. tostring(className) .. " for method " .. tostring(methodName))
            end
            table.insert(result, { name, instance })
         else
            M.LuaUnit.expandOneClass(result, name, instance)
         end
      end
   end

   return result
end

function M.LuaUnit.applyPatternFilter(patternIncFilter, listOfNameAndInst)
   local included, excluded = {}, {}
   for i, v in ipairs(listOfNameAndInst) do
      -- local name, instance = v[1], v[2]
      if patternFilter(patternIncFilter, v[1]) then
         table.insert(included, v)
      else
         table.insert(excluded, v)
      end
   end
   return included, excluded
end

local function getKeyInListWithGlobalFallback(key, listOfNameAndInst)
   local result = nil
   for i, v in ipairs(listOfNameAndInst) do
      if listOfNameAndInst[i][1] == key then
         result = listOfNameAndInst[i][2]
         break
      end
   end
   if not M.LuaUnit.asFunction(result) then result = _G[key] end
   return result
end

function M.LuaUnit:setupSuite(listOfNameAndInst)
   local setupSuite = getKeyInListWithGlobalFallback("setupSuite", listOfNameAndInst)
   if self.asFunction(setupSuite) then self:updateStatus(self:protectedCall(nil, setupSuite, "setupSuite")) end
end

function M.LuaUnit:teardownSuite(listOfNameAndInst)
   local teardownSuite = getKeyInListWithGlobalFallback("teardownSuite", listOfNameAndInst)
   if self.asFunction(teardownSuite) then self:updateStatus(self:protectedCall(nil, teardownSuite, "teardownSuite")) end
end

function M.LuaUnit:setupClass(className, instance)
   if type(instance) == "table" and self.asFunction(instance.setupClass) then
      self:updateStatus(self:protectedCall(instance, instance.setupClass, className .. ".setupClass"))
   end
end

function M.LuaUnit:teardownClass(className, instance)
   if type(instance) == "table" and self.asFunction(instance.teardownClass) then
      self:updateStatus(self:protectedCall(instance, instance.teardownClass, className .. ".teardownClass"))
   end
end

function M.LuaUnit:internalRunSuiteByInstances(listOfNameAndInst)
   --[[ Run an explicit list of tests. Each item of the list must be one of:
        * { function name, function instance }
        * { class name, class instance }
        * { class.method name, class instance }

        This function is internal to LuaUnit. The official API to perform this action is runSuiteByInstances()
        ]]

   local expandedList = self.expandClasses(listOfNameAndInst)
   if self.shuffle then randomizeTable(expandedList) end
   local filteredList, filteredOutList = self.applyPatternFilter(self.patternIncludeFilter, expandedList)

   self:startSuite(#filteredList, #filteredOutList)
   self:setupSuite(listOfNameAndInst)

   for i, v in ipairs(filteredList) do
      local name, instance = v[1], v[2]
      if M.LuaUnit.asFunction(instance) then
         self:execOneFunction(nil, name, nil, instance)
      else
         -- expandClasses() should have already taken care of sanitizing the input
         assert(type(instance) == "table")
         local className, methodName = M.LuaUnit.splitClassMethod(name)
         assert(className ~= nil)
         local methodInstance = instance[methodName]
         assert(methodInstance ~= nil)
         self:execOneFunction(className, methodName, instance, methodInstance)
      end
      if self.result.aborted then
         break -- "--error" or "--failure" option triggered
      end
   end

   if self.lastClassName ~= nil then self:endClass() end

   self:teardownSuite(listOfNameAndInst)
   self:endSuite()

   if self.result.aborted then
      print("LuaUnit ABORTED (as requested by --error or --failure option)")
      self:unregisterSuite()
      os.exit(-2)
   end
end

function M.LuaUnit:internalRunSuiteByNames(listOfName)
   --[[ Run LuaUnit with a list of generic names, coming either from command-line or from global
            namespace analysis. Convert the list into a list of (name, valid instances (table or function))
            and calls internalRunSuiteByInstances.
        ]]

   local instanceName, instance
   local listOfNameAndInst = {}

   for i, name in ipairs(listOfName) do
      local className, methodName = M.LuaUnit.splitClassMethod(name)
      if className then
         instanceName = className
         instance = _G[instanceName]

         if instance == nil then
            self:unregisterSuite()
            error("No such name in global space: " .. instanceName)
         end

         if type(instance) ~= "table" then
            self:unregisterSuite()
            error("Instance of " .. instanceName .. " must be a table, not " .. type(instance))
         end

         local methodInstance = instance[methodName]
         if methodInstance == nil then
            self:unregisterSuite()
            error("Could not find method in class " .. tostring(className) .. " for method " .. tostring(methodName))
         end
      else
         -- for functions and classes
         instanceName = name
         instance = _G[instanceName]
      end

      if instance == nil then
         self:unregisterSuite()
         error("No such name in global space: " .. instanceName)
      end

      if type(instance) ~= "table" and type(instance) ~= "function" then
         self:unregisterSuite()
         error("Name must match a function or a table: " .. instanceName)
      end

      table.insert(listOfNameAndInst, { name, instance })
   end

   self:internalRunSuiteByInstances(listOfNameAndInst)
end

function M.LuaUnit.run(...)
   -- Run some specific test classes.
   -- If no arguments are passed, run the class names specified on the
   -- command line. If no class name is specified on the command line
   -- run all classes whose name starts with 'Test'
   --
   -- If arguments are passed, they must be strings of the class names
   -- that you want to run or generic command line arguments (-o, -p, -v, ...)
   local runner = M.LuaUnit.new()
   return runner:runSuite(...)
end

function M.LuaUnit:registerSuite()
   -- register the current instance into our global array of instances
   -- print('-> Register suite')
   M.LuaUnit.instances[#M.LuaUnit.instances + 1] = self
end

function M.unregisterCurrentSuite()
   -- force unregister the last registered suite
   table.remove(M.LuaUnit.instances, #M.LuaUnit.instances)
end

function M.LuaUnit:unregisterSuite()
   -- print('<- Unregister suite')
   -- remove our current instqances from the global array of instances
   local instanceIdx = nil
   for i, instance in ipairs(M.LuaUnit.instances) do
      if instance == self then
         instanceIdx = i
         break
      end
   end

   if instanceIdx ~= nil then
      table.remove(M.LuaUnit.instances, instanceIdx) -- print('Unregister done')
   end
end

function M.LuaUnit:initFromArguments(...)
   --[[Parses all arguments from either command-line or direct call and set internal
        flags of LuaUnit runner according to it.

        Return the list of names which were possibly passed on the command-line or as arguments
        ]]
   local args = { ... }
   if type(args[1]) == "table" and args[1].__class__ == "LuaUnit" then
      -- run was called with the syntax M.LuaUnit:runSuite()
      -- we support both M.LuaUnit.run() and M.LuaUnit:run()
      -- strip out the first argument self to make it a command-line argument list
      table.remove(args, 1)
   end

   if #args == 0 then args = cmdline_argv end

   local options = pcall_or_abort(M.LuaUnit.parseCmdLine, args)

   -- We expect these option fields to be either `nil` or contain
   -- valid values, so it's safe to always copy them directly.
   self.verbosity = options.verbosity
   self.quitOnError = options.quitOnError
   self.quitOnFailure = options.quitOnFailure

   self.exeRepeat = options.exeRepeat
   self.patternIncludeFilter = options.pattern
   self.shuffle = options.shuffle

   options.output = options.output or os.getenv("LUAUNIT_OUTPUT")
   options.fname = options.fname or os.getenv("LUAUNIT_JUNIT_FNAME")

   if options.output then
      if options.output:lower() == "junit" and options.fname == nil then
         print("With junit output, a filename must be supplied with -n or --name")
         os.exit(-1)
      end
      pcall_or_abort(self.setOutputType, self, options.output, options.fname)
   end

   return options.testNames
end

function M.LuaUnit:runSuite(...)
   local testNames = self:initFromArguments(...)
   self:registerSuite()
   self:internalRunSuiteByNames(testNames or M.LuaUnit.collectTests())
   self:unregisterSuite()
   return self.result.notSuccessCount
end

function M.LuaUnit:runSuiteByInstances(listOfNameAndInst, commandLineArguments)
   --[[
        Run all test functions or tables provided as input.

        Input: a list of { name, instance }
            instance can either be a function or a table containing test functions starting with the prefix "test"

        return the number of failures and errors, 0 meaning success
        ]]
   -- parse the command-line arguments
   local testNames = self:initFromArguments(commandLineArguments)
   self:registerSuite()
   self:internalRunSuiteByInstances(listOfNameAndInst)
   self:unregisterSuite()
   return self.result.notSuccessCount
end

-- class LuaUnit

-- For compatbility with LuaUnit v2
M.run = M.LuaUnit.run
M.Run = M.LuaUnit.run

function M:setVerbosity(verbosity)
   -- set the verbosity value (as integer)
   M.LuaUnit.verbosity = verbosity
end
M.set_verbosity = M.setVerbosity
M.SetVerbosity = M.setVerbosity

return M