luaunit.lua

--[[
        luaunit.lua

Description: A unit testing framework
Homepage: https://github.com/bluebird75/luaunit
Development by Philippe Fremy <[email protected]>
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
    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 <[email protected]>')
  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(...)
  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
  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