diff options
| author | chai <chaifix@163.com> | 2021-10-26 11:32:46 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-10-26 11:32:46 +0800 |
| commit | 0549b1e5a8a3132005e275d6026db8003cb067d2 (patch) | |
| tree | f0d7751ec32ecf5c4d23997fa0ffd3450a5a755a /Resources/Libraries/luaunit/test/test_luaunit.lua | |
| parent | 32345800737b668011a87328cd3dcce59ec2934c (diff) | |
*rename folder
Diffstat (limited to 'Resources/Libraries/luaunit/test/test_luaunit.lua')
| -rw-r--r-- | Resources/Libraries/luaunit/test/test_luaunit.lua | 4413 |
1 files changed, 0 insertions, 4413 deletions
diff --git a/Resources/Libraries/luaunit/test/test_luaunit.lua b/Resources/Libraries/luaunit/test/test_luaunit.lua deleted file mode 100644 index 10fa019..0000000 --- a/Resources/Libraries/luaunit/test/test_luaunit.lua +++ /dev/null @@ -1,4413 +0,0 @@ ---[[ -Author: Philippe Fremy <phil@freehackers.org> -License: BSD License, see LICENSE.txt -]]-- - -local TABLE_REF_PAT='table: 0?x?[%x]+' -local TABLE_IDX_PAT='table %d%d' -local TABLE_IDX_REF_PAT='table %d%d%-0?x?[%x]+' - --- Return a function that appends its arguments to the `callInfo` table -local function callRecorder( callInfo ) - return function( ... ) - for _, v in pairs({...}) do - table.insert( callInfo, v ) - end - end -end - --- This is a bit tricky since the test uses the features that it tests. - -local function range(start, stop) - -- return list of { start ... stop } - local i - local ret = {} - i=start - while i <= stop do - table.insert(ret, i) - i = i + 1 - end - return ret -end - - -local lu = require('luaunit') - -local Mock = { __class__ = 'Mock' } - -function Mock.new(runner) - local t = lu.genericOutput.new(runner) - t.calls = {} - local t_MT = { - __index = function( tab, key ) - local callInfo = { key } - table.insert( tab.calls, callInfo ) - return callRecorder( callInfo ) - end - } - return setmetatable( t, t_MT ) -end - - -TestMock = {} - function TestMock:testMock() - local m = Mock.new() - m.titi( 42 ) - m.toto( 33, "abc", { 21} ) - lu.assertEquals( m.calls[1][1], 'titi' ) - lu.assertEquals( m.calls[1][2], 42 ) - lu.assertEquals( #m.calls[1], 2 ) - - lu.assertEquals( m.calls[2][1], 'toto' ) - lu.assertEquals( m.calls[2][2], 33 ) - lu.assertEquals( m.calls[2][3], 'abc' ) - lu.assertEquals( m.calls[2][4][1], 21 ) - lu.assertEquals( #m.calls[2], 4 ) - - lu.assertEquals( #m.calls, 2 ) - end - ------------------------------------------------------------------- --- --- Utility Tests --- ------------------------------------------------------------------- - -TestLuaUnitUtilities = { __class__ = 'TestLuaUnitUtilities' } - - function TestLuaUnitUtilities:setUp() - self.old_PRINT_TABLE_REF_IN_ERROR_MSG = lu.PRINT_TABLE_REF_IN_ERROR_MSG - end - - function TestLuaUnitUtilities:tearDown() - lu.PRINT_TABLE_REF_IN_ERROR_MSG = self.old_PRINT_TABLE_REF_IN_ERROR_MSG - end - - function TestLuaUnitUtilities:test_genSortedIndex() - lu.assertEquals( lu.private.__genSortedIndex( { 2, 5, 7} ), {1,2,3} ) - lu.assertEquals( lu.private.__genSortedIndex( { a='1', h='2', c='3' } ), {'a', 'c', 'h'} ) - lu.assertEquals( lu.private.__genSortedIndex( { 1, 'z', a='1', h='2', c='3' } ), { 1, 2, 'a', 'c', 'h' } ) - lu.assertEquals( lu.private.__genSortedIndex( { b=4, a=3, true, foo="bar", nil, bar=false, 42, c=5 } ), - { 1, 3, 'a', 'b', 'bar', 'c', 'foo' } ) - end - - function TestLuaUnitUtilities:test_sortedNextWorks() - local t1 = {} - local _ - t1['aaa'] = 'abc' - t1['ccc'] = 'def' - t1['bbb'] = 'cba' - - -- mimic semantics of "generic for" loop - local sortedNext, state = lu.private.sortedPairs(t1) - - local k, v = sortedNext( state, nil ) - lu.assertEquals( k, 'aaa' ) - lu.assertEquals( v, 'abc' ) - k, v = sortedNext( state, k ) - lu.assertEquals( k, 'bbb' ) - lu.assertEquals( v, 'cba' ) - k, v = sortedNext( state, k ) - lu.assertEquals( k, 'ccc' ) - lu.assertEquals( v, 'def' ) - k, v = sortedNext( state, k ) - lu.assertEquals( k, nil ) - lu.assertEquals( v, nil ) - - -- check if starting the iteration a second time works - k, v = sortedNext( state, nil ) - lu.assertEquals( k, 'aaa' ) - lu.assertEquals( v, 'abc' ) - - -- run a generic for loop (internally using a separate state) - local tested = {} - for _, v in lu.private.sortedPairs(t1) do table.insert(tested, v) end - lu.assertEquals( tested, {'abc', 'cba', 'def'} ) - - -- test bisection algorithm by searching for non-existing key values - k, v = sortedNext( state, '' ) -- '' would come before any of the keys - lu.assertNil( k ) - lu.assertNil( v ) - k, v = sortedNext( state, 'xyz' ) -- 'xyz' would be after any other key - lu.assertNil( k ) - lu.assertNil( v ) - - -- finally let's see if we successfully find an "out of sequence" key - k, v = sortedNext( state, 'bbb' ) - lu.assertEquals( k, 'ccc' ) - lu.assertEquals( v, 'def' ) - end - - function TestLuaUnitUtilities:test_sortedNextWorksOnTwoTables() - local t1 = { aaa = 'abc', ccc = 'def' } - local t2 = { ['3'] = '33', ['1'] = '11' } - - local sortedNext, state1, state2, _ - _, state1 = lu.private.sortedPairs(t1) - sortedNext, state2 = lu.private.sortedPairs(t2) - - local k, v = sortedNext( state1, nil ) - lu.assertEquals( k, 'aaa' ) - lu.assertEquals( v, 'abc' ) - - k, v = sortedNext( state2, nil ) - lu.assertEquals( k, '1' ) - lu.assertEquals( v, '11' ) - - k, v = sortedNext( state1, 'aaa' ) - lu.assertEquals( k, 'ccc' ) - lu.assertEquals( v, 'def' ) - - k, v = sortedNext( state2, '1' ) - lu.assertEquals( k, '3' ) - lu.assertEquals( v, '33' ) - end - - function TestLuaUnitUtilities:test_randomizeTable() - local t, tref, n = {}, {}, 20 - for i = 1, n do - t[i], tref[i] = i, i - end - lu.assertEquals( #t, n ) - - lu.private.randomizeTable( t ) - lu.assertEquals( #t, n ) - lu.assertNotEquals( t, tref) - table.sort(t) - lu.assertEquals( t, tref ) - end - - function TestLuaUnitUtilities:test_strSplitOneCharDelim() - local t = lu.private.strsplit( '\n', '122333' ) - lu.assertEquals( t[1], '122333') - lu.assertEquals( #t, 1 ) - - local t = lu.private.strsplit( '\n', '1\n22\n333\n' ) - lu.assertEquals( t[1], '1') - lu.assertEquals( t[2], '22') - lu.assertEquals( t[3], '333') - lu.assertEquals( t[4], '') - lu.assertEquals( #t, 4 ) - -- test invalid (empty) delimiter - lu.assertErrorMsgContains('delimiter is nil or empty string!', - lu.private.strsplit, '', '1\n22\n333\n') - lu.assertErrorMsgContains('delimiter is nil or empty string!', - lu.private.strsplit, nil, '1\n22\n333\n') - end - - function TestLuaUnitUtilities:test_strSplit3CharDelim() - local t = lu.private.strsplit( '2\n3', '1\n22\n332\n3' ) - lu.assertEquals( t[1], '1\n2') - lu.assertEquals( t[2], '3') - lu.assertEquals( t[3], '') - lu.assertEquals( #t, 3 ) - end - - function TestLuaUnitUtilities:test_strSplitWithNil() - lu.assertEquals( nil, lu.private.strsplit('-', nil) ) - end - - function TestLuaUnitUtilities:test_protectedCall() - local function boom() error("Something went wrong.") end - local err = lu.LuaUnit:protectedCall(nil, boom, "kaboom") - - -- check that err received the expected fields - lu.assertEquals(err.status, "ERROR") - lu.assertStrContains(err.msg, "Something went wrong.") - lu.assertStrMatches(err.trace, "^stack traceback:.*in %a+ 'kaboom'.*") - end - - function TestLuaUnitUtilities:test_prefixString() - lu.assertEquals( lu.private.prefixString( '12 ', 'ab\ncd\nde'), '12 ab\n12 cd\n12 de' ) - end - - function TestLuaUnitUtilities:test_is_table_equals() - -- Make sure that _is_table_equals() doesn't fall for these traps - -- (See https://github.com/bluebird75/luaunit/issues/48) - local A, B, C = {}, {}, {} - - A.self = A - B.self = B - lu.assertEquals(A, B) - - A, B = {}, {} - A.circular = C - B.circular = A - C.circular = B - lu.assertEquals(A, B) - lu.assertEquals(B, C) - lu.assertEquals(C, A) - - A = {} - A[{}] = A - lu.assertEquals( A, A ) - - A = {} - A[A] = 1 - lu.assertEquals( A, A ) - end - - function TestLuaUnitUtilities:test_suitableForMismatchFormatting() - lu.assertFalse( lu.private.tryMismatchFormatting( {1,2}, {2,1} ) ) - lu.assertFalse( lu.private.tryMismatchFormatting( nil, { 1,2,3} ) ) - lu.assertFalse( lu.private.tryMismatchFormatting( {1,2,3}, {} ) ) - lu.assertFalse( lu.private.tryMismatchFormatting( "123", "123" ) ) - lu.assertFalse( lu.private.tryMismatchFormatting( "123", "123" ) ) - lu.assertFalse( lu.private.tryMismatchFormatting( {'a','b','c'}, {'c', 'b', 'a'} )) - lu.assertFalse( lu.private.tryMismatchFormatting( {1,2,3, toto='titi'}, {1,2,3, toto='tata', tutu="bloup" } ) ) - lu.assertFalse( lu.private.tryMismatchFormatting( {1,2,3, [5]=1000}, {1,2,3} ) ) - - local i=0 - local l1, l2={}, {} - while i <= lu.LIST_DIFF_ANALYSIS_THRESHOLD+1 do - i = i + 1 - table.insert( l1, i ) - table.insert( l2, i+1 ) - end - - lu.assertTrue( lu.private.tryMismatchFormatting( l1, l2 ) ) - end - - - function TestLuaUnitUtilities:test_diffAnalysisThreshold() - local threshold = lu.LIST_DIFF_ANALYSIS_THRESHOLD - lu.assertFalse( lu.private.tryMismatchFormatting( range(1,threshold-1), range(1,threshold-2), lu.DEFAULT_DEEP_ANALYSIS ) ) - lu.assertTrue( lu.private.tryMismatchFormatting( range(1,threshold), range(1,threshold), lu.DEFAULT_DEEP_ANALYSIS ) ) - - lu.assertFalse( lu.private.tryMismatchFormatting( range(1,threshold-1), range(1,threshold-2), lu.DISABLE_DEEP_ANALYSIS ) ) - lu.assertFalse( lu.private.tryMismatchFormatting( range(1,threshold), range(1,threshold), lu.DISABLE_DEEP_ANALYSIS ) ) - - lu.assertTrue( lu.private.tryMismatchFormatting( range(1,threshold-1), range(1,threshold-2), lu.FORCE_DEEP_ANALYSIS ) ) - lu.assertTrue( lu.private.tryMismatchFormatting( range(1,threshold), range(1,threshold), lu.FORCE_DEEP_ANALYSIS ) ) - end - - function TestLuaUnitUtilities:test_table_ref_default() - local unknown_table_idx = 'table 00%-unknown ref' - - local ts = function(t) return t[1]..t[2] end - local t1 = {'1','2'} - lu.assertStrMatches( tostring(t1), TABLE_REF_PAT ) - lu.assertStrMatches( lu.private.table_ref(t1), TABLE_IDX_PAT ) - - local mt = { __tostring = ts } - setmetatable( t1, mt ) - lu.assertStrMatches( tostring(t1), '12' ) - lu.assertStrMatches( lu.private.table_ref(t1), TABLE_IDX_PAT ) - - -- how does it deal with protected metatable ? - -- metatable, obviously protected - local t1 = setmetatable( { 1, 2 }, { __metatable="private" } ) - lu.assertStrMatches( lu.private.table_ref(t1), TABLE_IDX_PAT ) - - -- metatable, protected but still returns a table so more difficult to catch - local t1 = setmetatable( { 1, 2 }, { __metatable={ "private" } } ) - lu.assertStrMatches( lu.private.table_ref(t1), TABLE_IDX_PAT ) - - -- protected metatable + __tostring, no way to get references - local t1 = setmetatable( { 1, 2 }, { __metatable="private", __tostring=ts } ) - lu.assertStrMatches( lu.private.table_ref(t1), unknown_table_idx ) - - local t1 = setmetatable( { 1, 2 }, { __metatable={ "private" }, __tostring=ts } ) - lu.assertStrMatches( lu.private.table_ref(t1), unknown_table_idx ) - end - - function TestLuaUnitUtilities:test_table_ref_print_ref() - local unknown_table_ref = 'table 00%-unknown ref' - - lu.PRINT_TABLE_REF_IN_ERROR_MSG = true - local ts = function(t) return t[1]..t[2] end - local t1 = {'1','2'} - lu.assertStrMatches( tostring(t1), TABLE_REF_PAT ) - lu.assertStrMatches( lu.private.table_ref(t1), 'table %d%d%-0?x?[%x]+' ) - - local mt = { __tostring = ts } - setmetatable( t1, mt ) - lu.assertStrMatches( tostring(t1), '12' ) - lu.assertStrMatches( lu.private.table_ref(t1), 'table %d%d%-0?x?[%x]+' ) - - -- how does it deal with protected metatable ? - -- metatable, obviously protected - local t1 = setmetatable( { 1, 2 }, { __metatable="private" } ) - lu.assertStrMatches( lu.private.table_ref(t1), 'table %d%d%-0?x?[%x]+' ) - - -- metatable, protected but still returns a table so more difficult to catch - local t1 = setmetatable( { 1, 2 }, { __metatable={ "private" } } ) - lu.assertStrMatches( lu.private.table_ref(t1), 'table %d%d%-0?x?[%x]+' ) - - -- protected metatable + __tostring, no way to get references - local t1 = setmetatable( { 1, 2 }, { __metatable="private", __tostring=ts } ) - lu.assertStrMatches( lu.private.table_ref(t1), unknown_table_ref ) - - local t1 = setmetatable( { 1, 2 }, { __metatable={ "private" }, __tostring=ts } ) - lu.assertStrMatches( lu.private.table_ref(t1), unknown_table_ref ) - end - - function TestLuaUnitUtilities:test_prettystr_numbers() - lu.assertEquals( lu.prettystr( 1 ), "1" ) - if lu._LUAVERSION < 'Lua 5.4' or lu._LUAVERSION:sub(1,6) == "LuaJIT" then - lu.assertEquals( lu.prettystr( 1 ), "1" ) - lu.assertEquals( lu.prettystr( 1.0 ), "1" ) - else - lu.assertEquals( lu.prettystr( 1 ), "1" ) - lu.assertEquals( lu.prettystr( 1.0 ), "1.0" ) - end - lu.assertEquals( lu.prettystr( 1.1 ), "1.1" ) - lu.assertEquals( lu.prettystr( 1/0 ), "#Inf" ) - lu.assertEquals( lu.prettystr( -1/0 ), "-#Inf" ) - lu.assertEquals( lu.prettystr( 0/0 ), "#NaN" ) - end - - function TestLuaUnitUtilities:test_prettystr_strings() - lu.assertEquals( lu.prettystr( 'abc' ), '"abc"' ) - lu.assertEquals( lu.prettystr( 'ab\ncd' ), '"ab\ncd"' ) - lu.assertEquals( lu.prettystr( 'ab"cd' ), "'ab\"cd'" ) - lu.assertEquals( lu.prettystr( "ab'cd" ), '"ab\'cd"' ) - end - - function TestLuaUnitUtilities:test_prettystr_tables1() - lu.assertEquals( lu.prettystr( {1,2,3} ), "{1, 2, 3}" ) - lu.assertEquals( lu.prettystr( {a=1,bb=2,ab=3} ), '{a=1, ab=3, bb=2}' ) - lu.assertEquals( lu.prettystr( { [{}] = 1 }), '{{}=1}' ) - lu.assertEquals( lu.prettystr( { 1, [{}] = 1, 2 }), '{1, 2, {}=1}' ) - lu.assertEquals( lu.prettystr( { 1, [{one=1}] = 1, 2, "test", false }), '{1, 2, "test", false, {one=1}=1}' ) - end - - function TestLuaUnitUtilities:test_prettystr_tables2() - -- test the (private) key string formatting within _table_tostring() - lu.assertEquals( lu.prettystr( {a = 1} ), '{a=1}' ) - lu.assertEquals( lu.prettystr( {a0 = 2} ), '{a0=2}' ) - lu.assertEquals( lu.prettystr( {['a0!'] = 3} ), '{"a0!"=3}' ) - lu.assertEquals( lu.prettystr( {["foo\nbar"] = 1}), [[{"foo -bar"=1}]] ) - lu.assertEquals( lu.prettystr( {["foo'bar"] = 2}), [[{"foo'bar"=2}]] ) - lu.assertEquals( lu.prettystr( {['foo"bar'] = 3}), [[{'foo"bar'=3}]] ) - end - - function TestLuaUnitUtilities:test_prettystr_tables3() - -- test with a table containing a metatable for __tostring - local t1 = {'1','2'} - lu.assertStrMatches( tostring(t1), 'table: 0?x?[%x]+' ) - lu.assertEquals( lu.prettystr(t1), '{"1", "2"}' ) - - -- add metatable - local function ts(t) return string.format( 'Point<%s,%s>', t[1], t[2] ) end - setmetatable( t1, { __tostring = ts } ) - - lu.assertEquals( tostring(t1), 'Point<1,2>' ) - lu.assertEquals( lu.prettystr(t1), 'Point<1,2>' ) - - local function ts2(t) - return string.format( 'Point:\n x=%s\n y=%s', t[1], t[2] ) - end - - local t2 = {'1','2'} - setmetatable( t2, { __tostring = ts2 } ) - - lu.assertEquals( tostring(t2), [[Point: - x=1 - y=2]] ) - lu.assertEquals( lu.prettystr(t2), [[Point: - x=1 - y=2]] ) - - -- nested table - local t3 = {'3', t1} - lu.assertEquals( lu.prettystr(t3), [[{"3", Point<1,2>}]] ) - - local t4 = {'3', t2} - lu.assertEquals( lu.prettystr(t4), [[{"3", Point: - x=1 - y=2}]] ) - - local t5 = {1,2,{3,4},string.rep('W', lu.LINE_LENGTH), t2, 33} - lu.assertEquals( lu.prettystr(t5), [[{ - 1, - 2, - {3, 4}, - "]]..string.rep('W', lu.LINE_LENGTH)..[[", - Point: - x=1 - y=2, - 33 -}]] ) - end - - function TestLuaUnitUtilities:test_prettystr_adv_tables() - local t1 = {1,2,3,4,5,6} - lu.assertEquals(lu.prettystr(t1), "{1, 2, 3, 4, 5, 6}" ) - - local t2 = {'aaaaaaaaaaaaaaaaa', 'bbbbbbbbbbbbbbbbbbbb', 'ccccccccccccccccc', 'ddddddddddddd', 'eeeeeeeeeeeeeeeeee', 'ffffffffffffffff', 'ggggggggggg', 'hhhhhhhhhhhhhh'} - lu.assertEquals(lu.prettystr(t2), table.concat( { - '{', - ' "aaaaaaaaaaaaaaaaa",', - ' "bbbbbbbbbbbbbbbbbbbb",', - ' "ccccccccccccccccc",', - ' "ddddddddddddd",', - ' "eeeeeeeeeeeeeeeeee",', - ' "ffffffffffffffff",', - ' "ggggggggggg",', - ' "hhhhhhhhhhhhhh"', - '}', - } , '\n' ) ) - - lu.assertTrue( lu.private.hasNewLine( lu.prettystr(t2)) ) - - local t2bis = { 1,2,3,'12345678901234567890123456789012345678901234567890123456789012345678901234567890', 4,5,6 } - lu.assertEquals(lu.prettystr(t2bis), [[{ - 1, - 2, - 3, - "12345678901234567890123456789012345678901234567890123456789012345678901234567890", - 4, - 5, - 6 -}]] ) - - local t3 = { l1a = { l2a = { l3a='012345678901234567890123456789012345678901234567890123456789' }, - l2b='bbb' }, l1b = 4} - lu.assertEquals(lu.prettystr(t3), [[{ - l1a={ - l2a={l3a="012345678901234567890123456789012345678901234567890123456789"}, - l2b="bbb" - }, - l1b=4 -}]] ) - - local t4 = { a=1, b=2, c=3 } - lu.assertEquals(lu.prettystr(t4), '{a=1, b=2, c=3}' ) - - local t5 = { t1, t2, t3 } - lu.assertEquals( lu.prettystr(t5), [[{ - {1, 2, 3, 4, 5, 6}, - { - "aaaaaaaaaaaaaaaaa", - "bbbbbbbbbbbbbbbbbbbb", - "ccccccccccccccccc", - "ddddddddddddd", - "eeeeeeeeeeeeeeeeee", - "ffffffffffffffff", - "ggggggggggg", - "hhhhhhhhhhhhhh" - }, - { - l1a={ - l2a={l3a="012345678901234567890123456789012345678901234567890123456789"}, - l2b="bbb" - }, - l1b=4 - } -}]] ) - - local t6 = { t1=t1, t2=t2, t3=t3, t4=t4 } - lu.assertEquals(lu.prettystr(t6),[[{ - t1={1, 2, 3, 4, 5, 6}, - t2={ - "aaaaaaaaaaaaaaaaa", - "bbbbbbbbbbbbbbbbbbbb", - "ccccccccccccccccc", - "ddddddddddddd", - "eeeeeeeeeeeeeeeeee", - "ffffffffffffffff", - "ggggggggggg", - "hhhhhhhhhhhhhh" - }, - t3={ - l1a={ - l2a={l3a="012345678901234567890123456789012345678901234567890123456789"}, - l2b="bbb" - }, - l1b=4 - }, - t4={a=1, b=2, c=3} -}]]) - end - - function TestLuaUnitUtilities:test_prettystrTableCycles() - local t = {} - t.__index = t - lu.assertStrMatches(lu.prettystr(t), "(<"..TABLE_IDX_PAT..">) {__index=%1}") - - local t1 = {} - local t2 = {} - t1.t2 = t2 - t2.t1 = t1 - local t3 = { t1 = t1, t2 = t2 } - lu.assertStrMatches(lu.prettystr(t1), "(<"..TABLE_IDX_PAT..">) {t2=(<"..TABLE_IDX_PAT..">) {t1=%1}}") - lu.assertStrMatches(lu.prettystr(t3), "(<"..TABLE_IDX_PAT..">) {t1=(<"..TABLE_IDX_PAT..">) {t2=(<"..TABLE_IDX_PAT..">) {t1=%2}}, t2=%3}") - - local t4 = {1,2} - local t5 = {3,4,t4} - t4[3] = t5 - lu.assertStrMatches(lu.prettystr(t5), "(<"..TABLE_IDX_PAT..">) {3, 4, (<"..TABLE_IDX_PAT..">) {1, 2, %1}}") - - local t6 = {} - t6[t6] = 1 - lu.assertStrMatches(lu.prettystr(t6), "(<"..TABLE_IDX_PAT..">) {%1=1}" ) - - local t7, t8 = {"t7"}, {"t8"} - t7[t8] = 1 - t8[t7] = 2 - lu.assertStrMatches(lu.prettystr(t7), '(<'..TABLE_IDX_PAT..'>) {"t7", (<'..TABLE_IDX_PAT..'>) {"t8", %1=2}=1}') - - local t9 = {"t9", {}} - t9[{t9}] = 1 - - lu.assertStrMatches(lu.prettystr(t9, true), '(<'..TABLE_IDX_PAT..'>) {\n?%s*"t9",\n?%s*(<'..TABLE_IDX_PAT..'>) {},\n?%s*(<'..TABLE_IDX_PAT..'>) {%1}=1\n?}') - end - - function TestLuaUnitUtilities:test_prettystrPairs() - local foo, bar, str1, str2 = nil, nil - - -- test all combinations of: foo = nil, "foo", "fo\no" (embedded - -- newline); and bar = nil, "bar", "bar\n" (trailing newline) - - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, "nil") - lu.assertEquals(str2, "nil") - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, "nil_B") - lu.assertEquals(str2, "nil") - - bar = "bar" - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, "nil") - lu.assertEquals(str2, '"bar"') - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, "nil_B") - lu.assertEquals(str2, '"bar"') - - bar = "bar\n" - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, "\nnil") - lu.assertEquals(str2, '\n"bar\n"') - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, "\nnil_A") - lu.assertEquals(str2, '\n"bar\n"') - - foo = "foo" - bar = nil - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, '"foo"') - lu.assertEquals(str2, "nil") - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, '"foo"_B') - lu.assertEquals(str2, "nil") - - bar = "bar" - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, '"foo"') - lu.assertEquals(str2, '"bar"') - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, '"foo"_B') - lu.assertEquals(str2, '"bar"') - - bar = "bar\n" - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, '\n"foo"') - lu.assertEquals(str2, '\n"bar\n"') - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, '\n"foo"_A') - lu.assertEquals(str2, '\n"bar\n"') - - foo = "fo\no" - bar = nil - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, '\n"fo\no"') - lu.assertEquals(str2, "\nnil") - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, '\n"fo\no"_A') - lu.assertEquals(str2, "\nnil") - - bar = "bar" - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, '\n"fo\no"') - lu.assertEquals(str2, '\n"bar"') - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, '\n"fo\no"_A') - lu.assertEquals(str2, '\n"bar"') - - bar = "bar\n" - str1, str2 = lu.private.prettystrPairs(foo, bar) - lu.assertEquals(str1, '\n"fo\no"') - lu.assertEquals(str2, '\n"bar\n"') - str1, str2 = lu.private.prettystrPairs(foo, bar, "_A", "_B") - lu.assertEquals(str1, '\n"fo\no"_A') - lu.assertEquals(str2, '\n"bar\n"') - end - - function TestLuaUnitUtilities:test_FailFmt() - -- raise failure from within nested functions - local function babar(level) - lu.private.fail_fmt(level, 'toto', "hex=%X", 123) - end - local function bar(level) - lu.private.fail_fmt(level, nil, "hex=%X", 123) - end - local function foo(level) - bar(level) - end - - local _, err = pcall(foo) -- default level 1 = error position in bar() - local line1, prefix = err:match("test[\\/]test_luaunit%.lua:(%d+): (.*)hex=7B$") - lu.assertEquals(prefix, lu.FAILURE_PREFIX) - lu.assertNotNil(line1) - - _, err = pcall(foo, 2) -- level 2 = error position within foo() - local line2 - line2 , prefix = err:match("test[\\/]test_luaunit%.lua:(%d+): (.*)hex=7B$") - lu.assertEquals(prefix, lu.FAILURE_PREFIX) - lu.assertNotNil(line2) - -- make sure that "line2" position is exactly 3 lines after "line1" - lu.assertEquals(tonumber(line2), tonumber(line1) + 3) - - _, err = pcall(babar, 1) - local _, prefix = err:match("test[\\/]test_luaunit%.lua:(%d+): (.*)hex=7B$") - lu.assertEquals(prefix, lu.FAILURE_PREFIX .. 'toto\n') - - end - - function TestLuaUnitUtilities:test_IsFunction() - -- previous LuaUnit.isFunction was superseded by LuaUnit.asFunction - -- (which can also serve as a boolean expression) - lu.assertNotNil( lu.LuaUnit.asFunction( function (v,y) end ) ) - lu.assertNil( lu.LuaUnit.asFunction( nil ) ) - lu.assertNil( lu.LuaUnit.asFunction( "not a function" ) ) - end - - function TestLuaUnitUtilities:test_splitClassMethod() - lu.assertEquals( lu.LuaUnit.splitClassMethod( 'toto' ), nil ) - lu.assertEquals( {lu.LuaUnit.splitClassMethod( 'toto.titi' )}, - {'toto', 'titi'} ) - end - - function TestLuaUnitUtilities:test_isTestName() - lu.assertEquals( lu.LuaUnit.isTestName( 'testToto' ), true ) - lu.assertEquals( lu.LuaUnit.isTestName( 'TestToto' ), true ) - lu.assertEquals( lu.LuaUnit.isTestName( 'TESTToto' ), true ) - lu.assertEquals( lu.LuaUnit.isTestName( 'xTESTToto' ), false ) - lu.assertEquals( lu.LuaUnit.isTestName( '' ), false ) - end - - function TestLuaUnitUtilities:test_parseCmdLine() - --test names - lu.assertEquals( lu.LuaUnit.parseCmdLine(), {} ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { 'someTest' } ), { testNames={'someTest'} } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { 'someTest', 'someOtherTest' } ), { testNames={'someTest', 'someOtherTest'} } ) - - -- verbosity - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--verbose' } ), { verbosity=lu.VERBOSITY_VERBOSE } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-v' } ), { verbosity=lu.VERBOSITY_VERBOSE } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--quiet' } ), { verbosity=lu.VERBOSITY_QUIET } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-q' } ), { verbosity=lu.VERBOSITY_QUIET } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-v', '-q' } ), { verbosity=lu.VERBOSITY_QUIET } ) - - --output - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--output', 'toto' } ), { output='toto'} ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-o', 'toto' } ), { output='toto'} ) - lu.assertErrorMsgContains( 'Missing argument after -o', lu.LuaUnit.parseCmdLine, { '-o', } ) - - --name - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--name', 'toto' } ), { fname='toto'} ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-n', 'toto' } ), { fname='toto'} ) - lu.assertErrorMsgContains( 'Missing argument after -n', lu.LuaUnit.parseCmdLine, { '-n', } ) - - --patterns - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--pattern', 'toto' } ), { pattern={'toto'} } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-p', 'toto' } ), { pattern={'toto'} } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-p', 'titi', '-p', 'toto' } ), { pattern={'titi', 'toto'} } ) - lu.assertErrorMsgContains( 'Missing argument after -p', lu.LuaUnit.parseCmdLine, { '-p', } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--exclude', 'toto' } ), { pattern={'!toto'} } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-x', 'toto' } ), { pattern={'!toto'} } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-x', 'titi', '-x', 'toto' } ), { pattern={'!titi', '!toto'} } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-x', 'titi', '-p', 'foo', '-x', 'toto' } ), { pattern={'!titi', 'foo', '!toto'} } ) - lu.assertErrorMsgContains( 'Missing argument after -x', lu.LuaUnit.parseCmdLine, { '-x', } ) - - -- repeat - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--repeat', '123' } ), { exeRepeat=123 } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-r', '123' } ), { exeRepeat=123 } ) - lu.assertErrorMsgContains( 'Malformed -r argument', lu.LuaUnit.parseCmdLine, { '-r', 'bad' } ) - lu.assertErrorMsgContains( 'Missing argument after -r', lu.LuaUnit.parseCmdLine, { '-r', } ) - - -- shuffle - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--shuffle' } ), { shuffle=true } ) - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-s' } ), { shuffle=true } ) - - --megamix - lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-p', 'toto', 'titi', '-v', 'tata', '-o', 'tintin', '-p', 'tutu', 'prout', '-n', 'toto.xml' } ), - { pattern={'toto', 'tutu'}, verbosity=lu.VERBOSITY_VERBOSE, output='tintin', testNames={'titi', 'tata', 'prout'}, fname='toto.xml' } ) - - lu.assertErrorMsgContains( 'option: -$', lu.LuaUnit.parseCmdLine, { '-$', } ) - end - - function TestLuaUnitUtilities:test_patternFilter() - lu.assertEquals( lu.private.patternFilter( nil, 'toto'), true ) - lu.assertEquals( lu.private.patternFilter( {}, 'toto'), true ) - - -- positive pattern - lu.assertEquals( lu.private.patternFilter( {'toto'}, 'toto'), true ) - lu.assertEquals( lu.private.patternFilter( {'toto'}, 'yyytotoxxx'), true ) - lu.assertEquals( lu.private.patternFilter( {'titi', 'toto'}, 'yyytotoxxx'), true ) - lu.assertEquals( lu.private.patternFilter( {'titi', 'toto'}, 'tutu'), false ) - lu.assertEquals( lu.private.patternFilter( {'titi', 'to..'}, 'yyytoxxx'), true ) - - -- negative pattern - lu.assertEquals( lu.private.patternFilter( {'!toto'}, 'toto'), false ) - lu.assertEquals( lu.private.patternFilter( {'!t.t.'}, 'titi'), false ) - lu.assertEquals( lu.private.patternFilter( {'!toto'}, 'titi'), true ) - lu.assertEquals( lu.private.patternFilter( {'!toto'}, 'yyytotoxxx'), false ) - lu.assertEquals( lu.private.patternFilter( {'!titi', '!toto'}, 'yyytotoxxx'), false ) - lu.assertEquals( lu.private.patternFilter( {'!titi', '!toto'}, 'tutu'), true ) - lu.assertEquals( lu.private.patternFilter( {'!titi', '!to..'}, 'yyytoxxx'), false ) - - -- combine patterns - lu.assertEquals( lu.private.patternFilter( { 'foo' }, 'foo'), true ) - lu.assertEquals( lu.private.patternFilter( { 'foo', '!foo' }, 'foo'), false ) - lu.assertEquals( lu.private.patternFilter( { 'foo', '!foo', 'foo' }, 'foo'), true ) - lu.assertEquals( lu.private.patternFilter( { 'foo', '!foo', 'foo', '!foo' }, 'foo'), false ) - - lu.assertEquals( lu.private.patternFilter( { '!foo' }, 'foo'), false ) - lu.assertEquals( lu.private.patternFilter( { '!foo', 'foo' }, 'foo'), true ) - lu.assertEquals( lu.private.patternFilter( { '!foo', 'foo', '!foo' }, 'foo'), false ) - lu.assertEquals( lu.private.patternFilter( { '!foo', 'foo', '!foo', 'foo' }, 'foo'), true ) - - lu.assertEquals( lu.private.patternFilter( { 'f..', '!foo', '__foo__' }, 'toto'), false ) - lu.assertEquals( lu.private.patternFilter( { 'f..', '!foo', '__foo__' }, 'fii'), true ) - lu.assertEquals( lu.private.patternFilter( { 'f..', '!foo', '__foo__' }, 'foo'), false ) - lu.assertEquals( lu.private.patternFilter( { 'f..', '!foo', '__foo__' }, '__foo__'), true ) - - lu.assertEquals( lu.private.patternFilter( { '!f..', 'foo', '!__foo__' }, 'toto'), false ) - lu.assertEquals( lu.private.patternFilter( { '!f..', 'foo', '!__foo__' }, 'fii'), false ) - lu.assertEquals( lu.private.patternFilter( { '!f..', 'foo', '!__foo__' }, 'foo'), true ) - lu.assertEquals( lu.private.patternFilter( { '!f..', 'foo', '!__foo__' }, '__foo__'), false ) - end - - function TestLuaUnitUtilities:test_applyPatternFilter() - local dummy = function() end - local testset = { - { 'toto.foo', dummy}, { 'toto.bar', dummy}, - { 'titi.foo', dummy}, { 'titi.bar', dummy}, - { 'tata.foo', dummy}, { 'tata.bar', dummy}, - { 'foo.bar', dummy}, { 'foobar.test', dummy}, - } - - -- default action: include everything - local included, excluded = lu.LuaUnit.applyPatternFilter( nil, testset ) - lu.assertEquals( #included, 8 ) - lu.assertEquals( excluded, {} ) - - -- single exclude pattern (= select anything not matching "bar") - included, excluded = lu.LuaUnit.applyPatternFilter( {'!bar'}, testset ) - lu.assertEquals( included, {testset[1], testset[3], testset[5]} ) - lu.assertEquals( #excluded, 5 ) - - -- single include pattern - included, excluded = lu.LuaUnit.applyPatternFilter( {'t.t.'}, testset ) - lu.assertEquals( #included, 6 ) - lu.assertEquals( excluded, {testset[7], testset[8]} ) - - -- single include and exclude patterns - included, excluded = lu.LuaUnit.applyPatternFilter( {'foo', '!test'}, testset ) - lu.assertEquals( included, {testset[1], testset[3], testset[5], testset[7]} ) - lu.assertEquals( #excluded, 4 ) - - -- multiple (specific) includes - included, excluded = lu.LuaUnit.applyPatternFilter( {'toto', 'titi'}, testset ) - lu.assertEquals( included, {testset[1], testset[2], testset[3], testset[4]} ) - lu.assertEquals( #excluded, 4 ) - - -- multiple excludes - included, excluded = lu.LuaUnit.applyPatternFilter( {'!tata', '!%.bar'}, testset ) - lu.assertEquals( included, {testset[1], testset[3], testset[8]} ) - lu.assertEquals( #excluded, 5 ) - - -- combined test - included, excluded = lu.LuaUnit.applyPatternFilter( {'t[oai]', 'bar$', 'test', '!%.b', '!titi'}, testset ) - lu.assertEquals( included, {testset[1], testset[5], testset[8]} ) - lu.assertEquals( #excluded, 5 ) - - --[[ Combining positive and negative filters ]]-- - included, excluded = lu.LuaUnit.applyPatternFilter( {'foo', 'bar', '!t.t.', '%.bar'}, testset ) - lu.assertEquals( included, {testset[2], testset[4], testset[6], testset[7], testset[8]} ) - lu.assertEquals( #excluded, 3 ) - end - - function TestLuaUnitUtilities:test_strMatch() - lu.assertEquals( lu.private.strMatch('toto', 't.t.'), true ) - lu.assertEquals( lu.private.strMatch('toto', 't.t.', 1, 4), true ) - lu.assertEquals( lu.private.strMatch('toto', 't.t.', 2, 5), false ) - lu.assertEquals( lu.private.strMatch('toto', '.t.t.'), false ) - lu.assertEquals( lu.private.strMatch('ototo', 't.t.'), false ) - lu.assertEquals( lu.private.strMatch('totot', 't.t.'), false ) - lu.assertEquals( lu.private.strMatch('ototot', 't.t.'), false ) - lu.assertEquals( lu.private.strMatch('ototot', 't.t.',2,3), false ) - lu.assertEquals( lu.private.strMatch('ototot', 't.t.',2,5), true ) - lu.assertEquals( lu.private.strMatch('ototot', 't.t.',2,6), false ) - end - - function TestLuaUnitUtilities:test_expandOneClass() - local result = {} - lu.LuaUnit.expandOneClass( result, 'titi', {} ) - lu.assertEquals( result, {} ) - - result = {} - lu.LuaUnit.expandOneClass( result, 'MyTestToto1', MyTestToto1 ) - lu.assertEquals( result, { - {'MyTestToto1.test1', MyTestToto1 }, - {'MyTestToto1.test2', MyTestToto1 }, - {'MyTestToto1.test3', MyTestToto1 }, - {'MyTestToto1.testa', MyTestToto1 }, - {'MyTestToto1.testb', MyTestToto1 }, - } ) - end - - function TestLuaUnitUtilities:test_expandClasses() - local result - result = lu.LuaUnit.expandClasses( {} ) - lu.assertEquals( result, {} ) - - result = lu.LuaUnit.expandClasses( { { 'MyTestFunction', MyTestFunction } } ) - lu.assertEquals( result, { { 'MyTestFunction', MyTestFunction } } ) - - result = lu.LuaUnit.expandClasses( { { 'MyTestToto1.test1', MyTestToto1 } } ) - lu.assertEquals( result, { { 'MyTestToto1.test1', MyTestToto1 } } ) - - result = lu.LuaUnit.expandClasses( { { 'MyTestToto1', MyTestToto1 } } ) - lu.assertEquals( result, { - {'MyTestToto1.test1', MyTestToto1 }, - {'MyTestToto1.test2', MyTestToto1 }, - {'MyTestToto1.test3', MyTestToto1 }, - {'MyTestToto1.testa', MyTestToto1 }, - {'MyTestToto1.testb', MyTestToto1 }, - } ) - end - - function TestLuaUnitUtilities:test_xmlEscape() - lu.assertEquals( lu.private.xmlEscape( 'abc' ), 'abc' ) - lu.assertEquals( lu.private.xmlEscape( 'a"bc' ), 'a"bc' ) - lu.assertEquals( lu.private.xmlEscape( "a'bc" ), 'a'bc' ) - lu.assertEquals( lu.private.xmlEscape( "a<b&c>" ), 'a<b&c>' ) - end - - function TestLuaUnitUtilities:test_xmlCDataEscape() - lu.assertEquals( lu.private.xmlCDataEscape( 'abc' ), 'abc' ) - lu.assertEquals( lu.private.xmlCDataEscape( 'a"bc' ), 'a"bc' ) - lu.assertEquals( lu.private.xmlCDataEscape( "a'bc" ), "a'bc" ) - lu.assertEquals( lu.private.xmlCDataEscape( "a<b&c>" ), 'a<b&c>' ) - lu.assertEquals( lu.private.xmlCDataEscape( "a<b]]>--" ), 'a<b]]>--' ) - end - - function TestLuaUnitUtilities:test_hasNewline() - lu.assertEquals( lu.private.hasNewLine(''), false ) - lu.assertEquals( lu.private.hasNewLine('abc'), false ) - lu.assertEquals( lu.private.hasNewLine('ab\nc'), true ) - end - - function TestLuaUnitUtilities:test_stripStackTrace2() - local errMsg1 = "example_with_luaunit.lua:130: in function 'test2_withFailure'" - local realStackTrace1=[[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 'internalRunSuiteByInstances' - ./luaunit.lua:1660: in function 'internalRunSuiteByNames' - ./luaunit.lua:1736: in function 'runSuite' - example_with_luaunit.lua:140: in main chunk - [C]: in ?]] - - local errMsg2 = 'example_with_luaunit.lua:58: expected 2, got 3' - local realStackTrace2=[[stack traceback: - 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 'internalRunSuiteByInstances' - ./luaunit.lua:1730: in function 'internalRunSuiteByNames' - ./luaunit.lua:1806: in function 'runSuite' - example_with_luaunit.lua:140: in main chunk - [C]: in ?]] - - local errMsg3 = './test\\test_luaunit.lua:3013: expected: 2, actual: 1' - local realStackTrace3 = [[stack traceback: - ./luaunit.lua:1331: in function 'failure' - ./luaunit.lua:1436: in function 'assertEquals' - ./test\test_luaunit.lua:3013: in function 'methodInstance' - ./luaunit.lua:3023: in function <./luaunit.lua:3023> - [C]: in function 'xpcall' - ./luaunit.lua:3023: in function 'protectedCall' - ./luaunit.lua:3104: in function 'execOneFunction' - ./luaunit.lua:3213: in function 'internalRunSuiteByInstances' - ./luaunit.lua:3277: in function 'internalRunSuiteByNames' - ... - ./luaunit.lua:3023: in function <./luaunit.lua:3023> - [C]: in function 'xpcall' - ./luaunit.lua:3023: in function 'protectedCall' - ./luaunit.lua:3104: in function 'execOneFunction' - ./luaunit.lua:3213: in function 'internalRunSuiteByInstances' - ./luaunit.lua:3277: in function 'internalRunSuiteByNames' - ./luaunit.lua:3327: in function <./luaunit.lua:3293> - (tail call): ? - run_unit_tests.lua:22: in main chunk - [C]: ? - ]] - - local errMsg4_1 = 'reduce_reporting.lua:7: expected: 2, actual: 1' - local errMsg4_2 = 'reduce_reporting.lua:12: expected: 2, actual: 1' - local errMsg4_3 = 'reduce_reporting.lua:20: expected: 2, actual: 1' - local realStackTrace4 = [[stack traceback: - ./luaunit.lua:1199: in function 'failure' - ./luaunit.lua:1304: in function 'assertEquals' - reduce_reporting.lua:7: in function 'my_assertEquals' - reduce_reporting.lua:12: in function 'my_sub_test_under_exec' - reduce_reporting.lua:20: in function 'my_test_under_exec' - ./luaunit.lua:2891: in function <./luaunit.lua:2891> - [C]: in function 'xpcall' - ./luaunit.lua:2891: in function 'protectedCall' - ./luaunit.lua:2972: in function 'execOneFunction' - ./luaunit.lua:3081: in function 'internalRunSuiteByInstances' - ./luaunit.lua:3145: in function 'internalRunSuiteByNames' - ./luaunit.lua:3195: in function 'runSuite' - reduce_reporting.lua:18: in main chunk - [C]: in ? - ]] - - local strippedStackTrace - local expectedStackTrace - - strippedStackTrace=lu.private.stripLuaunitTrace2( realStackTrace1, errMsg1 ) - expectedStackTrace=[[stack traceback: - example_with_luaunit.lua:130: in function 'test2_withFailure']] - lu.assertEquals( strippedStackTrace, expectedStackTrace ) - - strippedStackTrace=lu.private.stripLuaunitTrace2( realStackTrace2, errMsg2 ) - expectedStackTrace=[[stack traceback: - example_with_luaunit.lua:58: in function 'TestToto.test7']] - lu.assertEquals( strippedStackTrace, expectedStackTrace ) - - strippedStackTrace=lu.private.stripLuaunitTrace2( realStackTrace3, errMsg3 ) - expectedStackTrace=[[stack traceback: - ./test\test_luaunit.lua:3013: in function 'methodInstance']] - lu.assertEquals( strippedStackTrace, expectedStackTrace ) - - strippedStackTrace=lu.private.stripLuaunitTrace2( realStackTrace4, errMsg4_1 ) - expectedStackTrace=[[stack traceback: - reduce_reporting.lua:7: in function 'my_assertEquals' - reduce_reporting.lua:12: in function 'my_sub_test_under_exec' - reduce_reporting.lua:20: in function 'my_test_under_exec']] - lu.assertEquals( strippedStackTrace, expectedStackTrace ) - - strippedStackTrace=lu.private.stripLuaunitTrace2( realStackTrace4, errMsg4_2 ) - expectedStackTrace=[[stack traceback: - reduce_reporting.lua:12: in function 'my_sub_test_under_exec' - reduce_reporting.lua:20: in function 'my_test_under_exec']] - lu.assertEquals( strippedStackTrace, expectedStackTrace ) - - strippedStackTrace=lu.private.stripLuaunitTrace2( realStackTrace4, errMsg4_3 ) - expectedStackTrace=[[stack traceback: - reduce_reporting.lua:20: in function 'my_test_under_exec']] - lu.assertEquals( strippedStackTrace, expectedStackTrace ) - - - end - - function TestLuaUnitUtilities:test_lstrip() - lu.assertEquals(lu.private.lstrip("toto"), "toto") - lu.assertEquals(lu.private.lstrip("toto "), "toto ") - lu.assertEquals(lu.private.lstrip(" toto "), "toto ") - lu.assertEquals(lu.private.lstrip("\t\ttoto "), "toto ") - lu.assertEquals(lu.private.lstrip("\t \ttoto "), "toto ") - lu.assertEquals(lu.private.lstrip("\t \ttoto \n titi"), "toto \n titi") - lu.assertEquals(lu.private.lstrip(""), "") - end - - function TestLuaUnitUtilities:test_extractFileLineNbInfo() - local s - s = "luaunit2/example_with_luaunit.lua:124: in function 'test1_withFailure'" - lu.assertEquals(lu.private.extractFileLineInfo(s), "luaunit2/example_with_luaunit.lua:124") - - s = " ./test\\test_luaunit.lua:2996: expected: 2, actual: 1" - lu.assertEquals(lu.private.extractFileLineInfo(s), "./test\\test_luaunit.lua:2996" ) - end - - function TestLuaUnitUtilities:test_eps_value() - -- calculate epsilon - local local_eps = 1.0 - while (1.0 + 0.5 * local_eps) ~= 1.0 do - local_eps = 0.5 * local_eps - end - -- print( local_eps, lu.EPS) - lu.assertEquals( local_eps, lu.EPS ) - end - - ------------------------------------------------------------------- --- --- Outputter Tests --- ------------------------------------------------------------------- - -TestLuaUnitOutputters = { __class__ = 'TestOutputters' } - - -- JUnitOutput:startSuite() can raise errors on its own, cover those - function TestLuaUnitOutputters:testJUnitOutputErrors() - local runner = lu.LuaUnit.new() - runner:setOutputType('junit') - local outputter = runner.outputType.new(runner) - - -- missing file name - lu.assertErrorMsgContains('With Junit, an output filename must be supplied', - outputter.startSuite, outputter) - - -- test adding .xml extension, catch output error - outputter.fname = '/tmp/nonexistent.dir/foobar' - lu.assertErrorMsgContains('Could not open file for writing: /tmp/nonexistent.dir/foobar.xml', - outputter.startSuite, outputter) - end - ------------------------------------------------------------------- --- --- Assertion Tests --- ------------------------------------------------------------------- - -local function assertFailure( ... ) - -- ensure that execution generates a failure type error - lu.assertErrorMsgMatches(lu.FAILURE_PREFIX .. ".*", ...) -end - -local function assertBadFindArgTable( ... ) - lu.assertErrorMsgMatches( ".* bad argument .* to 'find' %(string expected, got table%)", ...) -end -local function assertBadFindArgNil( ... ) - lu.assertErrorMsgMatches( ".* bad argument .* to 'find' %(string expected, got nil%)", ...) -end -local function assertBadIndexNumber( ... ) - lu.assertErrorMsgMatches( ".* attempt to index .*a number value.*", ... ) -end -local function assertBadIndexNil( ... ) - lu.assertErrorMsgMatches( ".* attempt to index .*a nil value.*", ... ) -end -local function assertBadMethodNil( ... ) - lu.assertErrorMsgMatches( ".* attempt to call .*a nil value.*", ... ) -end - - -TestLuaUnitAssertions = { __class__ = 'TestLuaUnitAssertions' } - - function TestLuaUnitAssertions:test_assertEquals() - local f = function() return true end - local g = function() return true end - - lu.assertEquals( 1, 1 ) - lu.assertEquals( "abc", "abc" ) - lu.assertEquals( nil, nil ) - lu.assertEquals( true, true ) - lu.assertEquals( f, f) - lu.assertEquals( {1,2,3}, {1,2,3}) - lu.assertEquals( {one=1,two=2,three=3}, {one=1,two=2,three=3}) - lu.assertEquals( {one=1,two=2,three=3}, {two=2,three=3,one=1}) - lu.assertEquals( {one=1,two={1,2},three=3}, {two={1,2},three=3,one=1}) - lu.assertEquals( {one=1,two={1,{2,nil}},three=3}, {two={1,{2,nil}},three=3,one=1}) - lu.assertEquals( {nil}, {nil} ) - - assertFailure( lu.assertEquals, 1, 2) - assertFailure( lu.assertEquals, 1, "abc" ) - assertFailure( lu.assertEquals, 0, nil ) - assertFailure( lu.assertEquals, false, nil ) - assertFailure( lu.assertEquals, true, 1 ) - assertFailure( lu.assertEquals, f, 1 ) - assertFailure( lu.assertEquals, f, g ) - assertFailure( lu.assertEquals, {1,2,3}, {2,1,3} ) - assertFailure( lu.assertEquals, {1,2,3}, nil ) - assertFailure( lu.assertEquals, {1,2,3}, 1 ) - assertFailure( lu.assertEquals, {1,2,3}, true ) - assertFailure( lu.assertEquals, {1,2,3}, {one=1,two=2,three=3} ) - assertFailure( lu.assertEquals, {1,2,3}, {one=1,two=2,three=3,four=4} ) - assertFailure( lu.assertEquals, {one=1,two=2,three=3}, {2,1,3} ) - assertFailure( lu.assertEquals, {one=1,two=2,three=3}, nil ) - assertFailure( lu.assertEquals, {one=1,two=2,three=3}, 1 ) - assertFailure( lu.assertEquals, {one=1,two=2,three=3}, true ) - assertFailure( lu.assertEquals, {one=1,two=2,three=3}, {1,2,3} ) - assertFailure( lu.assertEquals, {one=1,two={1,2},three=3}, {two={2,1},three=3,one=1}) - - -- check assertions for which # operator returns two different length depending - -- on how the table is built, eventhough the final table is the same - local t1 = {1, nil, 3} -- length is 3 - local t2 = {1, [3]=3} -- length is 1 - lu.assertEquals( t1, t2 ) - end - - function TestLuaUnitAssertions:test_assertEqualsTableWithCycles() - - -- Table with same cyclic structrure should compare equal - local t1, t2 = {1}, {1} - t1.self = t1 - t2.self = t2 - lu.assertEquals( t1, t2 ) - - -- add one differing element - t1[2] = 2 - t2[2] = 3 - lu.assertNotEquals( t1, t2 ) - - -- cross cycle - local t3, t4 = {}, {} - t3.other = t4 - t4.other = t3 - lu.assertEquals( t3, t4 ) - - -- 3 level cycle - local t5a, t6a, t7a = {}, {}, {} - t6a.t5 = t5a - t7a.t6 = t6a - t5a.t7 = t7a - - local t5b, t6b, t7b = {}, {}, {} - t6b.t5 = t5b - t7b.t6 = t6b - t5b.t7 = t7b - - lu.assertEquals( t5a, t5b ) - lu.assertEquals( t6a, t6b ) - lu.assertEquals( t7a, t7b ) - lu.assertNotEquals( t5a, t6a ) - - -- 3 level cycles vs 2 level cycles - local t8a, t9a, t10a = {}, {}, {} - t8a.other = t9a - t9a.other = t10a - t10a.other = t8a - - local t8b, t9b = {}, {} - t8b.other = t9b - t9b.other = t8b - -- print( 't8a='..lu.prettystr(t8a)) - -- print( 't8b='..lu.prettystr(t8b)) - lu.assertNotEquals( t8a, t8b ) - - local t11, t12 = {}, {} - t11.cycle = t8a - t12.cycle = t8b - lu.assertNotEquals( t11, t12 ) - - -- issue #116 - local a={} - local b={} - a.x = b; b.x = a - local a1={} - local b1={} - a1.x = b1; b1.x = a1 - lu.assertEquals(a, a1) - end - - function TestLuaUnitAssertions:test_assertEqualsTableAsKeys() - assertFailure( lu.assertEquals, {[{}] = 1}, { [{}] = 1}) - assertFailure( lu.assertEquals, {[{one=1, two=2}] = 1}, { [{two=2, one=1}] = 1}) - assertFailure( lu.assertEquals, {[{1}]=2, [{1}]=3}, {[{1}]=3, [{1}]=2} ) - assertFailure( lu.assertEquals, {[{1}]=2, [{1}]=3}, {[{1}]=2, [{1}]=3} ) - - assertFailure( lu.assertEquals, {[{}] = 1}, {[{}] = 2}) - assertFailure( lu.assertEquals, {[{}] = 1}, {[{one=1}] = 2}) - assertFailure( lu.assertEquals, {[{}] = 1}, {[{}] = 1, 2}) - assertFailure( lu.assertEquals, {[{}] = 1}, {[{}] = 1, [{}] = 1}) - assertFailure( lu.assertEquals, {[{"one"}]=1}, {[{"one", 1}]=2} ) - assertFailure( lu.assertEquals, {[{"one"}]=1,[{"one"}]=1}, {[{"one"}]=1} ) - end - - function TestLuaUnitAssertions:test_assertAlmostEquals() - lu.assertAlmostEquals( 1, 1, 0.1 ) - lu.assertAlmostEquals( 1, 1 ) -- default margin (= M.EPS) - lu.assertAlmostEquals( 1, 1, 0 ) -- zero margin - assertFailure( lu.assertAlmostEquals, 0, lu.EPS, 0 ) -- zero margin - - lu.assertAlmostEquals( 1, 1.1, 0.2 ) - lu.assertAlmostEquals( -1, -1.1, 0.2 ) - lu.assertAlmostEquals( 0.1, -0.1, 0.3 ) - lu.assertAlmostEquals( 0.1, -0.1, 0.2 ) - - -- Due to rounding errors, these user-supplied margins are too small. - -- The tests should respect them, and so are required to fail. - assertFailure( lu.assertAlmostEquals, 1, 1.1, 0.1 ) - assertFailure( lu.assertAlmostEquals, -1, -1.1, 0.1 ) - -- Check that an explicit zero margin gets respected too - assertFailure( lu.assertAlmostEquals, 1.1 - 1, 0.1, 0 ) - assertFailure( lu.assertAlmostEquals, -1 - (-1.1), 0.1, 0 ) - -- Tests pass when adding M.EPS, either explicitly or implicitly - lu.assertAlmostEquals( 1, 1.1, 0.1 + lu.EPS) - lu.assertAlmostEquals( 1.1 - 1, 0.1 ) - lu.assertAlmostEquals( -1, -1.1, 0.1 + lu.EPS ) - lu.assertAlmostEquals( -1 - (-1.1), 0.1 ) - - assertFailure( lu.assertAlmostEquals, 1, 1.11, 0.1 ) - assertFailure( lu.assertAlmostEquals, -1, -1.11, 0.1 ) - end - - function TestLuaUnitAssertions:test_assertAlmostEqualsTables() - lu.assertAlmostEquals( {1}, {1}, 0.1 ) - lu.assertAlmostEquals( {1}, {1} ) -- default margin (= M.EPS) - lu.assertAlmostEquals( {1}, {1}, 0 ) -- zero margin - assertFailure( lu.assertAlmostEquals, {0}, {lu.EPS}, 0 ) -- zero margin - - lu.assertAlmostEquals( {1}, {1.1}, 0.2 ) - lu.assertAlmostEquals( {-1}, {-1.1}, 0.2 ) - lu.assertAlmostEquals( {0.1}, {-0.1}, 0.3 ) - lu.assertAlmostEquals( {0.1}, {-0.1}, 0.2 ) - lu.assertAlmostEquals( {1, -1, 0.1, 0.1}, - {1.1, -1.1, 0.1, -0.1}, 0.3 ) - - lu.assertAlmostEquals( {a=1, b=-1, c=0.1, d=0.1}, - {a=1.1, b=-1.1, c=0.1, d=-0.1}, 0.3 ) - - lu.assertAlmostEquals( {0, {a=1, b=-1, c=0.1, d=0.1}}, - {0, {a=1.1, b=-1.1, c=0.1, d=-0.1}}, 0.3 ) - - -- Due to rounding errors, these user-supplied margins are too small. - -- The tests should respect them, and so are required to fail. - assertFailure( lu.assertAlmostEquals, {1}, {1.1}, 0.1 ) - assertFailure( lu.assertAlmostEquals, {-1}, {-1.1}, 0.1 ) - -- Check that an explicit zero margin gets respected too - assertFailure( lu.assertAlmostEquals, {1.1 - 1}, {0.1}, 0 ) - assertFailure( lu.assertAlmostEquals, {-1 - (-1.1)}, {0.1}, 0 ) - -- Tests pass when adding M.EPS, either explicitly or implicitly - lu.assertAlmostEquals( 1, 1.1, 0.1 + lu.EPS) - lu.assertAlmostEquals( 1.1 - 1, 0.1 ) - lu.assertAlmostEquals( -1, -1.1, 0.1 + lu.EPS ) - lu.assertAlmostEquals( -1 - (-1.1), 0.1 ) - lu.assertAlmostEquals( { 1, 1.1-1, -1}, - {1.1, 0.1, -1.1}, - 0.1 + lu.EPS ) - - -- tables with more diversity - lu.assertAlmostEquals( {1 , 'abc', nil, false, true, {1,2} }, - {1.1, 'abc', nil, false, true, {1,2} }, - 0.3) - - lu.assertAlmostEquals( {1 , 'abc', { 2, 3}, false, true, {1,2} }, - {1.1, 'abc', {2.1, 3.2}, false, true, {1,2} }, - 0.3) - - - -- difference on something else than numeric comparison - assertFailure( lu.assertAlmostEquals, {1, 'abc'}, {1, 'def'}, 0.1 ) - assertFailure( lu.assertAlmostEquals, {1, false}, {1, true}, 0.1 ) - assertFailure( lu.assertAlmostEquals, {1, 'abc'}, {1, nil}, 0.1 ) - end - - function TestLuaUnitAssertions:test_assertAlmostEqualsErrors() - lu.assertErrorMsgContains( "margin must be a number", lu.assertAlmostEquals, -1, 1, "foobar" ) - lu.assertErrorMsgContains( "must supply only number or table arguments", lu.assertAlmostEquals, -1, nil, 0 ) - lu.assertErrorMsgContains( "must supply only number or table arguments", lu.assertAlmostEquals, nil, nil, 0 ) - lu.assertErrorMsgContains( "must supply only number or table arguments", lu.assertAlmostEquals, '123', '345', 0 ) - lu.assertErrorMsgContains( "margin must not be negative", lu.assertAlmostEquals, 1, 1.1, -0.1 ) - end - - function TestLuaUnitAssertions:test_assertNotEquals() - local f = function() return true end - local g = function() return true end - - lu.assertNotEquals( 1, 2 ) - lu.assertNotEquals( "abc", 2 ) - lu.assertNotEquals( "abc", "def" ) - lu.assertNotEquals( 1, 2) - lu.assertNotEquals( 1, "abc" ) - lu.assertNotEquals( 0, nil ) - lu.assertNotEquals( false, nil ) - lu.assertNotEquals( true, 1 ) - lu.assertNotEquals( f, 1 ) - lu.assertNotEquals( f, g ) - lu.assertNotEquals( {one=1,two=2,three=3}, true ) - lu.assertNotEquals( {one=1,two={1,2},three=3}, {two={2,1},three=3,one=1} ) - - assertFailure( lu.assertNotEquals, 1, 1) - assertFailure( lu.assertNotEquals, "abc", "abc" ) - assertFailure( lu.assertNotEquals, nil, nil ) - assertFailure( lu.assertNotEquals, true, true ) - assertFailure( lu.assertNotEquals, f, f) - assertFailure( lu.assertNotEquals, {one=1,two={1,{2,nil}},three=3}, {two={1,{2,nil}},three=3,one=1}) - end - - function TestLuaUnitAssertions:test_assertNotAlmostEquals() - lu.assertNotAlmostEquals( 1, 1.2, 0.1 ) - lu.assertNotAlmostEquals( 1, 1.01 ) -- default margin (= M.EPS) - lu.assertNotAlmostEquals( 1, 1.01, 0 ) -- zero margin - lu.assertNotAlmostEquals( 0, lu.EPS, 0 ) -- zero margin - - lu.assertNotAlmostEquals( 1, 1.3, 0.2 ) - lu.assertNotAlmostEquals( -1, -1.3, 0.2 ) - lu.assertNotAlmostEquals( 0.1, -0.1, 0.1 ) - - lu.assertNotAlmostEquals( 1, 1.1, 0.09 ) - lu.assertNotAlmostEquals( -1, -1.1, 0.09 ) - lu.assertNotAlmostEquals( 0.1, -0.1, 0.11 ) - - -- Due to rounding errors, these user-supplied margins are too small. - -- The tests should respect them, and so are expected to pass. - lu.assertNotAlmostEquals( 1, 1.1, 0.1 ) - lu.assertNotAlmostEquals( -1, -1.1, 0.1 ) - -- Check that an explicit zero margin gets respected too - lu.assertNotAlmostEquals( 1.1 - 1, 0.1, 0 ) - lu.assertNotAlmostEquals( -1 - (-1.1), 0.1, 0 ) - -- Tests fail when adding M.EPS, either explicitly or implicitly - assertFailure( lu.assertNotAlmostEquals, 1, 1.1, 0.1 + lu.EPS) - assertFailure( lu.assertNotAlmostEquals, 1.1 - 1, 0.1 ) - assertFailure( lu.assertNotAlmostEquals, -1, -1.1, 0.1 + lu.EPS ) - assertFailure( lu.assertNotAlmostEquals, -1 - (-1.1), 0.1 ) - - assertFailure( lu.assertNotAlmostEquals, 1, 1.11, 0.2 ) - assertFailure( lu.assertNotAlmostEquals, -1, -1.11, 0.2 ) - lu.assertErrorMsgContains( "must supply only number arguments", lu.assertNotAlmostEquals, -1, 1, "foobar" ) - lu.assertErrorMsgContains( "must supply only number arguments", lu.assertNotAlmostEquals, -1, nil, 0 ) - lu.assertErrorMsgContains( "must supply only number arguments", lu.assertNotAlmostEquals, nil, 1, 0 ) - lu.assertErrorMsgContains( "margin must not be negative", lu.assertNotAlmostEquals, 1, 1.1, -0.1 ) - end - - function TestLuaUnitAssertions:test_assertNotEqualsDifferentTypes2() - lu.assertNotEquals( 2, "abc" ) - end - - function TestLuaUnitAssertions:test_assertIsTrue() - lu.assertIsTrue(true) - -- assertIsTrue is strict - assertFailure( lu.assertIsTrue, false) - assertFailure( lu.assertIsTrue, nil ) - assertFailure( lu.assertIsTrue, 0) - assertFailure( lu.assertIsTrue, 1) - assertFailure( lu.assertIsTrue, "") - assertFailure( lu.assertIsTrue, "abc") - assertFailure( lu.assertIsTrue, function() return true end ) - assertFailure( lu.assertIsTrue, {} ) - assertFailure( lu.assertIsTrue, { 1 } ) - end - - function TestLuaUnitAssertions:test_assertNotIsTrue() - assertFailure( lu.assertNotIsTrue, true) - lu.assertNotIsTrue( false) - lu.assertNotIsTrue( nil ) - lu.assertNotIsTrue( 0) - lu.assertNotIsTrue( 1) - lu.assertNotIsTrue( "") - lu.assertNotIsTrue( "abc") - lu.assertNotIsTrue( function() return true end ) - lu.assertNotIsTrue( {} ) - lu.assertNotIsTrue( { 1 } ) - end - - function TestLuaUnitAssertions:test_assertIsFalse() - lu.assertIsFalse(false) - assertFailure( lu.assertIsFalse, nil) -- assertIsFalse is strict ! - assertFailure( lu.assertIsFalse, true) - assertFailure( lu.assertIsFalse, 0 ) - assertFailure( lu.assertIsFalse, 1 ) - assertFailure( lu.assertIsFalse, "" ) - assertFailure( lu.assertIsFalse, "abc" ) - assertFailure( lu.assertIsFalse, function() return true end ) - assertFailure( lu.assertIsFalse, {} ) - assertFailure( lu.assertIsFalse, { 1 } ) - end - - function TestLuaUnitAssertions:test_assertNotIsFalse() - assertFailure(lu.assertNotIsFalse, false) - lu.assertNotIsFalse( true) - lu.assertNotIsFalse( 0 ) - lu.assertNotIsFalse( 1 ) - lu.assertNotIsFalse( "" ) - lu.assertNotIsFalse( "abc" ) - lu.assertNotIsFalse( function() return true end ) - lu.assertNotIsFalse( {} ) - lu.assertNotIsFalse( { 1 } ) - end - - function TestLuaUnitAssertions:test_assertEvalToTrue() - lu.assertEvalToTrue(true) - assertFailure( lu.assertEvalToTrue, false) - assertFailure( lu.assertEvalToTrue, nil ) - lu.assertEvalToTrue(0) - lu.assertEvalToTrue(1) - lu.assertEvalToTrue("") - lu.assertEvalToTrue("abc") - lu.assertEvalToTrue( function() return true end ) - lu.assertEvalToTrue( {} ) - lu.assertEvalToTrue( { 1 } ) - end - - function TestLuaUnitAssertions:test_assertEvalToFalse() - lu.assertEvalToFalse(false) - lu.assertEvalToFalse(nil) - assertFailure( lu.assertEvalToFalse, true) - assertFailure( lu.assertEvalToFalse, 0 ) - assertFailure( lu.assertEvalToFalse, 1 ) - assertFailure( lu.assertEvalToFalse, "" ) - assertFailure( lu.assertEvalToFalse, "abc" ) - assertFailure( lu.assertEvalToFalse, function() return true end ) - assertFailure( lu.assertEvalToFalse, {} ) - assertFailure( lu.assertEvalToFalse, { 1 } ) - end - - function TestLuaUnitAssertions:test_assertNil() - lu.assertNil(nil) - assertFailure( lu.assertTrue, false) - assertFailure( lu.assertNil, 0) - assertFailure( lu.assertNil, "") - assertFailure( lu.assertNil, "abc") - assertFailure( lu.assertNil, function() return true end ) - assertFailure( lu.assertNil, {} ) - assertFailure( lu.assertNil, { 1 } ) - end - - function TestLuaUnitAssertions:test_assertNotNil() - assertFailure( lu.assertNotNil, nil) - lu.assertNotNil( false ) - lu.assertNotNil( 0 ) - lu.assertNotNil( "" ) - lu.assertNotNil( "abc" ) - lu.assertNotNil( function() return true end ) - lu.assertNotNil( {} ) - lu.assertNotNil( { 1 } ) - end - - function TestLuaUnitAssertions:test_assertStrContains() - lu.assertStrContains( 'abcdef', 'abc' ) - lu.assertStrContains( 'abcdef', 'bcd' ) - lu.assertStrContains( 'abcdef', 'abcdef' ) - lu.assertStrContains( 'abc0', 0 ) - assertFailure( lu.assertStrContains, 'ABCDEF', 'abc' ) - assertFailure( lu.assertStrContains, '', 'abc' ) - lu.assertStrContains( 'abcdef', '' ) - assertFailure( lu.assertStrContains, 'abcdef', 'abcx' ) - assertFailure( lu.assertStrContains, 'abcdef', 'abcdefg' ) - assertFailure( lu.assertStrContains, 'abcdef', 0 ) - assertBadFindArgTable( lu.assertStrContains, 'abcdef', {} ) - assertBadFindArgNil( lu.assertStrContains, 'abcdef', nil ) - - lu.assertStrContains( 'abcdef', 'abc', false ) - lu.assertStrContains( 'abcdef', 'abc', true ) - lu.assertStrContains( 'abcdef', 'a.c', true ) - - assertFailure( lu.assertStrContains, 'abcdef', '.abc', true ) - end - - function TestLuaUnitAssertions:test_assertStrIContains() - lu.assertStrIContains( 'ABcdEF', 'aBc' ) - lu.assertStrIContains( 'abCDef', 'bcd' ) - lu.assertStrIContains( 'abcdef', 'abcDef' ) - assertFailure( lu.assertStrIContains, '', 'aBc' ) - lu.assertStrIContains( 'abcDef', '' ) - assertFailure( lu.assertStrIContains, 'abcdef', 'abcx' ) - assertFailure( lu.assertStrIContains, 'abcdef', 'abcdefg' ) - end - - function TestLuaUnitAssertions:test_assertNotStrContains() - assertFailure( lu.assertNotStrContains, 'abcdef', 'abc' ) - assertFailure( lu.assertNotStrContains, 'abcdef', 'bcd' ) - assertFailure( lu.assertNotStrContains, 'abcdef', 'abcdef' ) - lu.assertNotStrContains( '', 'abc' ) - assertFailure( lu.assertNotStrContains, 'abcdef', '' ) - assertFailure( lu.assertNotStrContains, 'abc0', 0 ) - lu.assertNotStrContains( 'abcdef', 'abcx' ) - lu.assertNotStrContains( 'abcdef', 'abcdefg' ) - assertBadFindArgTable( lu.assertNotStrContains, 'abcdef', {} ) - assertBadFindArgNil( lu.assertNotStrContains, 'abcdef', nil ) - - assertFailure( lu.assertNotStrContains, 'abcdef', 'abc', false ) - assertFailure( lu.assertNotStrContains, 'abcdef', 'a.c', true ) - lu.assertNotStrContains( 'abcdef', 'a.cx', true ) - end - - function TestLuaUnitAssertions:test_assertNotStrIContains() - assertFailure( lu.assertNotStrIContains, 'aBcdef', 'abc' ) - assertFailure( lu.assertNotStrIContains, 'abcdef', 'aBc' ) - assertFailure( lu.assertNotStrIContains, 'abcdef', 'bcd' ) - assertFailure( lu.assertNotStrIContains, 'abcdef', 'abcdef' ) - lu.assertNotStrIContains( '', 'abc' ) - assertFailure( lu.assertNotStrIContains, 'abcdef', '' ) - assertBadIndexNumber( lu.assertNotStrIContains, 'abc0', 0 ) - lu.assertNotStrIContains( 'abcdef', 'abcx' ) - lu.assertNotStrIContains( 'abcdef', 'abcdefg' ) - assertBadMethodNil( lu.assertNotStrIContains, 'abcdef', {} ) - assertBadIndexNil( lu.assertNotStrIContains, 'abcdef', nil ) - end - - function TestLuaUnitAssertions:test_assertStrMatches() - lu.assertStrMatches( 'abcdef', 'abcdef' ) - lu.assertStrMatches( 'abcdef', '..cde.' ) - assertFailure( lu.assertStrMatches, 'abcdef', '..def') - assertFailure( lu.assertStrMatches, 'abCDEf', '..cde.') - lu.assertStrMatches( 'abcdef', 'bcdef', 2 ) - lu.assertStrMatches( 'abcdef', 'bcde', 2, 5 ) - lu.assertStrMatches( 'abcdef', 'b..e', 2, 5 ) - lu.assertStrMatches( 'abcdef', 'ab..e', nil, 5 ) - assertFailure( lu.assertStrMatches, 'abcdef', '' ) - assertFailure( lu.assertStrMatches, '', 'abcdef' ) - - assertFailure( lu.assertStrMatches, 'abcdef', 0 ) - assertBadFindArgTable( lu.assertStrMatches, 'abcdef', {} ) - assertBadFindArgNil( lu.assertStrMatches, 'abcdef', nil ) - end - - function TestLuaUnitAssertions:test_assertItemsEquals() - lu.assertItemsEquals(nil, nil) - lu.assertItemsEquals({},{}) - lu.assertItemsEquals({1,2,3}, {3,1,2}) - lu.assertItemsEquals({nil},{nil}) - lu.assertItemsEquals({one=1,two=2,three=3}, {two=2,one=1,three=3}) - lu.assertItemsEquals({one=1,two=2,three=3}, {a=1,b=2,c=3}) - lu.assertItemsEquals({1,2,three=3}, {3,1,two=2}) - - assertFailure(lu.assertItemsEquals, {1}, {}) - assertFailure(lu.assertItemsEquals, nil, {1,2,3}) - assertFailure(lu.assertItemsEquals, {1,2,3}, nil) - assertFailure(lu.assertItemsEquals, {1,2,3,4}, {3,1,2}) - assertFailure(lu.assertItemsEquals, {1,2,3}, {3,1,2,4}) - assertFailure(lu.assertItemsEquals, {one=1,two=2,three=3,four=4}, {a=1,b=2,c=3}) - assertFailure(lu.assertItemsEquals, {one=1,two=2,three=3}, {a=1,b=2,c=3,d=4}) - assertFailure(lu.assertItemsEquals, {1,2,three=3}, {3,4,a=1,b=2}) - assertFailure(lu.assertItemsEquals, {1,2,three=3,four=4}, {3,a=1,b=2}) - - lu.assertItemsEquals({one=1,two={1,2},three=3}, {one={1,2},two=1,three=3}) - lu.assertItemsEquals({one=1, - two={1,{3,2,one=1}}, - three=3}, - {two={1,{3,2,one=1}}, - one=1, - three=3}) - -- itemsEquals is not recursive: - assertFailure( lu.assertItemsEquals,{1,{2,1},3}, {3,1,{1,2}}) - assertFailure( lu.assertItemsEquals,{one=1,two={1,2},three=3}, {one={2,1},two=1,three=3}) - assertFailure( lu.assertItemsEquals,{one=1,two={1,{3,2,one=1}},three=3}, {two={{3,one=1,2},1},one=1,three=3}) - assertFailure( lu.assertItemsEquals,{one=1,two={1,{3,2,one=1}},three=3}, {two={{3,2,one=1},1},one=1,three=3}) - - assertFailure(lu.assertItemsEquals, {one=1,two=2,three=3}, {two=2,one=1,three=2}) - assertFailure(lu.assertItemsEquals, {one=1,two=2,three=3}, {two=2,one=1,four=4}) - assertFailure(lu.assertItemsEquals, {one=1,two=2,three=3}, {two=2,one=1,'three'}) - assertFailure(lu.assertItemsEquals, {one=1,two=2,three=3}, {two=2,one=1,nil}) - assertFailure(lu.assertItemsEquals, {one=1,two=2,three=3}, {two=2,one=1}) - end - - function TestLuaUnitAssertions:test_assertTableContains() - local t = {3, 'some value', 1, 2} - - assertFailure(lu.assertTableContains, t, 0) - lu.assertTableContains(t, 1) - lu.assertTableContains(t, 2) - lu.assertTableContains(t, 3) - assertFailure(lu.assertTableContains, t, 4) - lu.assertTableContains(t, 'some value') - assertFailure(lu.assertTableContains, t, 'other value') - - t = {red = 'cherry', yellow = 'lemon', blue = 'grape'} - - lu.assertTableContains(t, 'lemon') - lu.assertTableContains(t, 'grape') - lu.assertTableContains(t, 'cherry') - assertFailure(lu.assertTableContains, t, 'kiwi') - - t = {a={1,2,3}, b={4,5,6} } - lu.assertTableContains(t, {1,2,3} ) - lu.assertTableContains(t, {4,5,6} ) - assertFailure(lu.assertTableContains, t, {3,2,1} ) - - - end - - function TestLuaUnitAssertions:test_assertNotTableContains() - local t = {3, 'some value', 1, 2} - - lu.assertNotTableContains(t, 0) - assertFailure(lu.assertNotTableContains, t, 1) - assertFailure(lu.assertNotTableContains, t, 2) - assertFailure(lu.assertNotTableContains, t, 3) - lu.assertNotTableContains(t, 4) - assertFailure(lu.assertNotTableContains, t, 'some value') - lu.assertNotTableContains(t, 'other value') - - t = {red = 'cherry', yellow = 'lemon', blue = 'grape'} - - assertFailure(lu.assertNotTableContains, t, 'lemon') - assertFailure(lu.assertNotTableContains, t, 'grape') - assertFailure(lu.assertNotTableContains, t, 'cherry') - lu.assertNotTableContains(t, 'kiwi') - end - - function TestLuaUnitAssertions:test_assertIsNumber() - lu.assertIsNumber(1) - lu.assertIsNumber(1.4) - assertFailure(lu.assertIsNumber, "hi there!") - assertFailure(lu.assertIsNumber, nil) - assertFailure(lu.assertIsNumber, {}) - assertFailure(lu.assertIsNumber, {1,2,3}) - assertFailure(lu.assertIsNumber, {1}) - assertFailure(lu.assertIsNumber, coroutine.create( function(v) local y=v+1 end ) ) - assertFailure(lu.assertIsNumber, true) - end - - function TestLuaUnitAssertions:test_assertIsNaN() - assertFailure(lu.assertIsNaN, "hi there!") - assertFailure(lu.assertIsNaN, nil) - assertFailure(lu.assertIsNaN, {}) - assertFailure(lu.assertIsNaN, {1,2,3}) - assertFailure(lu.assertIsNaN, {1}) - assertFailure(lu.assertIsNaN, coroutine.create( function(v) local y=v+1 end ) ) - lu.assertIsNaN(0 / 0) - lu.assertIsNaN(-0 / 0) - lu.assertIsNaN(0 / -0) - lu.assertIsNaN(-0 / -0) - local inf = math.huge - lu.assertIsNaN(inf / inf) - lu.assertIsNaN(-inf / inf) - lu.assertIsNaN(inf / -inf) - lu.assertIsNaN(-inf / -inf) - lu.assertIsNaN(inf - inf) - lu.assertIsNaN((-inf) + inf) - lu.assertIsNaN(inf + (-inf)) - lu.assertIsNaN((-inf) - (-inf)) - lu.assertIsNaN(0 * inf) - lu.assertIsNaN(-0 * inf) - lu.assertIsNaN(0 * -inf) - lu.assertIsNaN(-0 * -inf) - lu.assertIsNaN(math.sqrt(-1)) - if lu._LUAVERSION == "Lua 5.1" or lu._LUAVERSION == "Lua 5.2" then - -- Lua 5.3 will complain/error "bad argument #2 to 'fmod' (zero)" - lu.assertIsNaN(math.fmod(1, 0)) - lu.assertIsNaN(math.fmod(1, -0)) - end - lu.assertIsNaN(math.fmod(inf, 1)) - lu.assertIsNaN(math.fmod(-inf, 1)) - assertFailure(lu.assertIsNaN, 0 / 1) -- 0.0 - assertFailure(lu.assertIsNaN, 1 / 0) -- inf - assertFailure(lu.assertIsNaN, -1 / 0)-- -inf - end - - function TestLuaUnitAssertions:test_assertNotIsNaN() - -- not NaN - lu.assertNotIsNaN( "hi there!") - lu.assertNotIsNaN( nil) - lu.assertNotIsNaN( {}) - lu.assertNotIsNaN( {1,2,3}) - lu.assertNotIsNaN( {1}) - lu.assertNotIsNaN( coroutine.create( function(v) local y=v+1 end ) ) - - -- is NaN - lu.assertFailure( lu.assertNotIsNaN, 0 / 0) - lu.assertFailure( lu.assertNotIsNaN, -0 / 0) - lu.assertFailure( lu.assertNotIsNaN, 0 / -0) - lu.assertFailure( lu.assertNotIsNaN, -0 / -0) - local inf = math.huge - lu.assertFailure( lu.assertNotIsNaN, inf / inf) - lu.assertFailure( lu.assertNotIsNaN, -inf / inf) - lu.assertFailure( lu.assertNotIsNaN, inf / -inf) - lu.assertFailure( lu.assertNotIsNaN, -inf / -inf) - lu.assertFailure( lu.assertNotIsNaN, inf - inf) - lu.assertFailure( lu.assertNotIsNaN, (-inf) + inf) - lu.assertFailure( lu.assertNotIsNaN, inf + (-inf)) - lu.assertFailure( lu.assertNotIsNaN, (-inf) - (-inf)) - lu.assertFailure( lu.assertNotIsNaN, 0 * inf) - lu.assertFailure( lu.assertNotIsNaN, -0 * inf) - lu.assertFailure( lu.assertNotIsNaN, 0 * -inf) - lu.assertFailure( lu.assertNotIsNaN, -0 * -inf) - lu.assertFailure( lu.assertNotIsNaN, math.sqrt(-1)) - if lu._LUAVERSION == "Lua 5.1" or lu._LUAVERSION == "Lua 5.2" then - -- Lua 5.3 will complain/error "bad argument #2 to 'fmod' (zero)" - lu.assertFailure( lu.assertNotIsNaN, math.fmod(1, 0)) - lu.assertFailure( lu.assertNotIsNaN, math.fmod(1, -0)) - end - lu.assertFailure( lu.assertNotIsNaN, math.fmod(inf, 1)) - lu.assertFailure( lu.assertNotIsNaN, math.fmod(-inf, 1)) - - -- not NaN - assertFailure(lu.assertNotIsNaN, 0 / 1) -- 0.0 - assertFailure(lu.assertNotIsNaN, 1 / 0) -- inf - assertFailure(lu.assertNotIdNaN, -1 / 0) -- -inf - end - - function TestLuaUnitAssertions:test_assertIsInf() - assertFailure(lu.assertIsInf, "hi there!") - assertFailure(lu.assertIsInf, nil) - assertFailure(lu.assertIsInf, {}) - assertFailure(lu.assertIsInf, {1,2,3}) - assertFailure(lu.assertIsInf, {1}) - assertFailure(lu.assertIsInf, coroutine.create( function(v) local y=v+1 end ) ) - - assertFailure(lu.assertIsInf, 0 ) - assertFailure(lu.assertIsInf, 1 ) - assertFailure(lu.assertIsInf, 0 / 0) -- NaN - assertFailure(lu.assertIsInf, -0 / 0) -- NaN - assertFailure(lu.assertIsInf, 0 / 1) -- 0.0 - - lu.assertIsInf(1 / 0) -- inf - lu.assertIsInf(math.log(0)) -- -inf - lu.assertIsInf(math.huge) -- inf - lu.assertIsInf(-math.huge) -- -inf - end - - function TestLuaUnitAssertions:test_assertIsPlusInf() - assertFailure(lu.assertIsPlusInf, "hi there!") - assertFailure(lu.assertIsPlusInf, nil) - assertFailure(lu.assertIsPlusInf, {}) - assertFailure(lu.assertIsPlusInf, {1,2,3}) - assertFailure(lu.assertIsPlusInf, {1}) - assertFailure(lu.assertIsPlusInf, coroutine.create( function(v) local y=v+1 end ) ) - - assertFailure(lu.assertIsPlusInf, 0 ) - assertFailure(lu.assertIsPlusInf, 1 ) - assertFailure(lu.assertIsPlusInf, 0 / 0) -- NaN - assertFailure(lu.assertIsPlusInf, -0 / 0) -- NaN - assertFailure(lu.assertIsPlusInf, 0 / 1) -- 0.0 - assertFailure(lu.assertIsPlusInf, math.log(0)) -- -inf - assertFailure(lu.assertIsPlusInf, -math.huge) -- -inf - - lu.assertIsPlusInf(1 / 0) -- inf - lu.assertIsPlusInf(math.huge) -- inf - - -- behavior with -0 is lua version dependant: - -- lua51, lua53: -0 does NOT represent the value minus zero BUT plus zero - -- lua52, luajit: -0 represents the value minus zero - -- this is verified with the value 1/-0 - -- lua 5.1, 5.3: 1/-0 = inf - -- lua 5.2, luajit: 1/-0 = -inf - if lu._LUAVERSION ~= "Lua 5.2" and lu._LUAVERSION:sub(1,6) ~= "LuaJIT" then - lu.assertIsPlusInf( 1/-0 ) - else - assertFailure( lu.assertIsPlusInf, 1/-0 ) - end - end - - - function TestLuaUnitAssertions:test_assertIsMinusInf() - assertFailure(lu.assertIsMinusInf, "hi there!") - assertFailure(lu.assertIsMinusInf, nil) - assertFailure(lu.assertIsMinusInf, {}) - assertFailure(lu.assertIsMinusInf, {1,2,3}) - assertFailure(lu.assertIsMinusInf, {1}) - assertFailure(lu.assertIsMinusInf, coroutine.create( function(v) local y=v+1 end ) ) - - assertFailure(lu.assertIsMinusInf, 0 ) - assertFailure(lu.assertIsMinusInf, 1 ) - assertFailure(lu.assertIsMinusInf, 0 / 0) -- NaN - assertFailure(lu.assertIsMinusInf, -0 / 0) -- NaN - assertFailure(lu.assertIsMinusInf, 0 / 1) -- 0.0 - assertFailure(lu.assertIsMinusInf, -math.log(0)) -- inf - assertFailure(lu.assertIsMinusInf, math.huge) -- inf - - lu.assertIsMinusInf( math.log(0)) -- -inf - lu.assertIsMinusInf(-1 / 0) -- -inf - lu.assertIsMinusInf(-math.huge) -- -inf - - -- behavior with -0 is lua version dependant: - -- lua51, lua53: -0 does NOT represent the value minus zero BUT plus zero - -- lua52, luajit: -0 represents the value minus zero - -- this is verified with the value 1/-0 - -- lua 5.1, 5.3: 1/-0 = inf - -- lua 5.2, luajit: 1/-0 = -inf - if lu._LUAVERSION ~= "Lua 5.2" and lu._LUAVERSION:sub(1,6) ~= "LuaJIT" then - assertFailure( lu.assertIsMinusInf, 1/-0 ) - else - lu.assertIsMinusInf( 1/-0 ) - end - - end - - function TestLuaUnitAssertions:test_assertNotIsInf() - -- not inf - lu.assertNotIsInf( "hi there!") - lu.assertNotIsInf( nil) - lu.assertNotIsInf( {}) - lu.assertNotIsInf( {1,2,3}) - lu.assertNotIsInf( {1}) - lu.assertNotIsInf( coroutine.create( function(v) local y=v+1 end ) ) - - -- not inf - lu.assertNotIsInf( 0 ) - lu.assertNotIsInf( 1 ) - lu.assertNotIsInf( 0 / 0) -- NaN - lu.assertNotIsInf( -0 / 0) -- NaN - lu.assertNotIsInf( 0 / 1) -- 0.0 - - -- inf - assertFailure( lu.assertNotIsInf, 1 / 0) -- inf - assertFailure( lu.assertNotIsInf, math.log(0)) -- -inf - assertFailure( lu.assertNotIsInf, math.huge) -- inf - assertFailure( lu.assertNotIsInf, math.huge) -- -inf - end - - function TestLuaUnitAssertions:test_assertNotIsPlusInf() - -- not inf - lu.assertNotIsPlusInf( "hi there!") - lu.assertNotIsPlusInf( nil) - lu.assertNotIsPlusInf( {}) - lu.assertNotIsPlusInf( {1,2,3}) - lu.assertNotIsPlusInf( {1}) - lu.assertNotIsPlusInf( coroutine.create( function(v) local y=v+1 end ) ) - - lu.assertNotIsPlusInf( 0 ) - lu.assertNotIsPlusInf( 1 ) - lu.assertNotIsPlusInf( 0 / 0) -- NaN - lu.assertNotIsPlusInf( -0 / 0) -- NaN - lu.assertNotIsPlusInf( 0 / 1) -- 0.0 - lu.assertNotIsPlusInf( math.log(0)) -- -inf - lu.assertNotIsPlusInf( -math.huge) -- -inf - - -- inf - assertFailure( lu.assertNotIsPlusInf, 1 / 0) -- inf - assertFailure( lu.assertNotIsPlusInf, math.huge) -- inf - end - - - function TestLuaUnitAssertions:test_assertNotIsMinusInf() - -- not inf - lu.assertNotIsMinusInf( "hi there!") - lu.assertNotIsMinusInf( nil) - lu.assertNotIsMinusInf( {}) - lu.assertNotIsMinusInf( {1,2,3}) - lu.assertNotIsMinusInf( {1}) - lu.assertNotIsMinusInf( coroutine.create( function(v) local y=v+1 end ) ) - - lu.assertNotIsMinusInf( 0 ) - lu.assertNotIsMinusInf( 1 ) - lu.assertNotIsMinusInf( 0 / 0) -- NaN - lu.assertNotIsMinusInf( -0 / 0) -- NaN - lu.assertNotIsMinusInf( 0 / 1) -- 0.0 - lu.assertNotIsMinusInf( -math.log(0)) -- inf - lu.assertNotIsMinusInf( math.huge) -- inf - - -- inf - assertFailure( lu.assertNotIsMinusInf, math.log(0)) -- -inf - assertFailure( lu.assertNotIsMinusInf, -1 / 0) -- -inf - assertFailure( lu.assertNotIsMinusInf, -math.huge) -- -inf - end - - -- enable it only for debugging - --[[ - function Xtest_printHandlingOfZeroAndInf() - local inf = 1/0 - print( ' inf = ' .. inf ) - print( '-inf = ' .. -inf ) - print( ' 1/inf = ' .. 1/inf ) - print( '-1/inf = ' .. -1/inf ) - print( ' 1/-inf = ' .. 1/-inf ) - print( '-1/-inf = ' .. -1/-inf ) - print() - print( ' 1/-0 = ' .. 1/-0 ) - print() - print( ' -0 = ' .. -0 ) - print( ' 0/-1 = ' .. 0/-1 ) - print( ' 0*-1 = ' .. 0*-1 ) - print( '-0/-1 = ' .. -0/-1 ) - print( '-0*-1 = ' .. -0*-1 ) - print( '(-0)/-1 = ' .. (-0)/-1 ) - print( ' 1/(0/-1) = ' .. 1/(0/-1) ) - print( ' 1/(-0/-1) = ' .. 1/(-0/-1) ) - print( '-1/(0/-1) = ' .. -1/(0/-1) ) - print( '-1/(-0/-1) = ' .. -1/(-0/-1) ) - - print() - local minusZero = -1 / (1/0) - print( 'minusZero = -1 / (1/0)' ) - print( 'minusZero = '..minusZero) - print( ' 1/minusZero = ' .. 1/minusZero ) - print() - print( 'minusZero/-1 = ' .. minusZero/-1 ) - print( 'minusZero*-1 = ' .. minusZero*-1 ) - print( ' 1/(minusZero/-1) = ' .. 1/(minusZero/-1) ) - print( '-1/(minusZero/-1) = ' .. -1/(minusZero/-1) ) - - end - ]] - - --[[ #### Important note when dealing with -0 and infinity #### - - 1. Dealing with infinity is consistent, the only difference is whether the resulting 0 is integer or float - - Lua 5.3: dividing by infinity yields float 0 - With inf = 1/0: - -inf = -inf - 1/inf = 0.0 - -1/inf = -0.0 - 1/-inf = -0.0 - -1/-inf = 0.0 - - Lua 5.2 and 5.1 and luajit: dividing by infinity yields integer 0 - -inf =-1.#INF - 1/inf = 0 - -1/inf = -0 - 1/-inf = -0 - -1/-inf = 0 - - 2. Dealing with minus 0 is totally inconsistent mathematically and accross lua versions if you use the syntax -0. - It works correctly if you create the value by minusZero = -1 / (1/0) - - Enable the function above to see the extent of the damage of -0 : - - Lua 5.1: - * -0 is consistently considered as 0 - * 0 multipllied or diveded by -1 is still 0 - * -0 multipllied or diveded by -1 is still 0 - - Lua 5.2 and LuaJIT: - * -0 is consistently -0 - * 0 multipllied or diveded by -1 is correctly -0 - * -0 multipllied or diveded by -1 is correctly 0 - - Lua 5.3: - * -0 is consistently considered as 0 - * 0 multipllied by -1 is correctly -0 but divided by -1 yields 0 - * -0 multipllied by -1 is 0 but diveded by -1 is -0 - ]] - - function TestLuaUnitAssertions:test_assertIsPlusZero() - assertFailure(lu.assertIsPlusZero, "hi there!") - assertFailure(lu.assertIsPlusZero, nil) - assertFailure(lu.assertIsPlusZero, {}) - assertFailure(lu.assertIsPlusZero, {1,2,3}) - assertFailure(lu.assertIsPlusZero, {1}) - assertFailure(lu.assertIsPlusZero, coroutine.create( function(v) local y=v+1 end ) ) - - local inf = 1/0 - assertFailure(lu.assertIsPlusZero, 1 ) - assertFailure(lu.assertIsPlusZero, 0 / 0) -- NaN - assertFailure(lu.assertIsPlusZero, -0 / 0) -- NaN - assertFailure(lu.assertIsPlusZero, math.log(0)) -- inf - assertFailure(lu.assertIsPlusZero, math.huge) -- inf - assertFailure(lu.assertIsPlusZero, -math.huge) -- -inf - assertFailure(lu.assertIsPlusZero, -1/inf) -- -0.0 - - lu.assertIsPlusZero( 0 / 1) - lu.assertIsPlusZero( 0 ) - lu.assertIsPlusZero( 1/inf ) - - -- behavior with -0 is lua version dependant, see note above - if lu._LUAVERSION ~= "Lua 5.2" and lu._LUAVERSION:sub(1,6) ~= "LuaJIT" then - lu.assertIsPlusZero( -0 ) - else - assertFailure( lu.assertIsPlusZero, -0 ) - end - end - - function TestLuaUnitAssertions:test_assertNotIsPlusZero() - -- not plus zero - lu.assertNotIsPlusZero( "hi there!") - lu.assertNotIsPlusZero( nil) - lu.assertNotIsPlusZero( {}) - lu.assertNotIsPlusZero( {1,2,3}) - lu.assertNotIsPlusZero( {1}) - lu.assertNotIsPlusZero( coroutine.create( function(v) local y=v+1 end ) ) - - local inf = 1/0 - lu.assertNotIsPlusZero( 1 ) - lu.assertNotIsPlusZero( 0 / 0) -- NaN - lu.assertNotIsPlusZero( -0 / 0) -- NaN - lu.assertNotIsPlusZero( math.log(0)) -- inf - lu.assertNotIsPlusZero( math.huge) -- inf - lu.assertNotIsPlusZero( -math.huge) -- -inf - lu.assertNotIsPlusZero( -1/inf ) -- -0.0 - - -- plus zero - assertFailure( lu.assertNotIsPlusZero, 0 / 1) - assertFailure( lu.assertNotIsPlusZero, 0 ) - assertFailure( lu.assertNotIsPlusZero, 1/inf ) - - -- behavior with -0 is lua version dependant, see note above - if lu._LUAVERSION ~= "Lua 5.2" and lu._LUAVERSION:sub(1,6) ~= "LuaJIT" then - assertFailure( lu.assertNotIsPlusZero, -0 ) - else - lu.assertNotIsPlusZero( -0 ) - end - end - - - function TestLuaUnitAssertions:test_assertIsMinusZero() - assertFailure(lu.assertIsMinusZero, "hi there!") - assertFailure(lu.assertIsMinusZero, nil) - assertFailure(lu.assertIsMinusZero, {}) - assertFailure(lu.assertIsMinusZero, {1,2,3}) - assertFailure(lu.assertIsMinusZero, {1}) - assertFailure(lu.assertIsMinusZero, coroutine.create( function(v) local y=v+1 end ) ) - - local inf = 1/0 - assertFailure(lu.assertIsMinusZero, 1 ) - assertFailure(lu.assertIsMinusZero, 0 / 0) -- NaN - assertFailure(lu.assertIsMinusZero, -0 / 0) -- NaN - assertFailure(lu.assertIsMinusZero, math.log(0)) -- inf - assertFailure(lu.assertIsMinusZero, math.huge) -- inf - assertFailure(lu.assertIsMinusZero, -math.huge) -- -inf - assertFailure(lu.assertIsMinusZero, 1/inf) -- -0.0 - assertFailure(lu.assertIsMinusZero, 0 ) - - - lu.assertIsMinusZero( -1/inf ) - lu.assertIsMinusZero( 1/-inf ) - - -- behavior with -0 is lua version dependant, see note above - if lu._LUAVERSION ~= "Lua 5.2" and lu._LUAVERSION:sub(1,6) ~= "LuaJIT" then - assertFailure( lu.assertIsMinusZero, -0 ) - else - lu.assertIsMinusZero( -0 ) - end - end - - function TestLuaUnitAssertions:test_assertNotIsMinusZero() - lu.assertNotIsMinusZero( "hi there!") - lu.assertNotIsMinusZero( nil) - lu.assertNotIsMinusZero( {}) - lu.assertNotIsMinusZero( {1,2,3}) - lu.assertNotIsMinusZero( {1}) - lu.assertNotIsMinusZero( coroutine.create( function(v) local y=v+1 end ) ) - - local inf = 1/0 - lu.assertNotIsMinusZero( 1 ) - lu.assertNotIsMinusZero( 0 / 0) -- NaN - lu.assertNotIsMinusZero( -0 / 0) -- NaN - lu.assertNotIsMinusZero( math.log(0)) -- inf - lu.assertNotIsMinusZero( math.huge) -- inf - lu.assertNotIsMinusZero( -math.huge) -- -inf - lu.assertNotIsMinusZero( 0 ) - lu.assertNotIsMinusZero( 1/inf) -- -0.0 - - assertFailure( lu.assertNotIsMinusZero, -1/inf ) - assertFailure( lu.assertNotIsMinusZero, 1/-inf ) - - -- behavior with -0 is lua version dependant, see note above - if lu._LUAVERSION ~= "Lua 5.2" and lu._LUAVERSION:sub(1,6) ~= "LuaJIT" then - lu.assertNotIsMinusZero( -0 ) - else - assertFailure( lu.assertNotIsMinusZero, -0 ) - end - end - - function TestLuaUnitAssertions:test_assertIsString() - assertFailure(lu.assertIsString, 1) - assertFailure(lu.assertIsString, 1.4) - lu.assertIsString("hi there!") - assertFailure(lu.assertIsString, nil) - assertFailure(lu.assertIsString, {}) - assertFailure(lu.assertIsString, {1,2,3}) - assertFailure(lu.assertIsString, {1}) - assertFailure(lu.assertIsString, coroutine.create( function(v) local y=v+1 end ) ) - assertFailure(lu.assertIsString, true) - end - - function TestLuaUnitAssertions:test_assertIsTable() - assertFailure(lu.assertIsTable, 1) - assertFailure(lu.assertIsTable, 1.4) - assertFailure(lu.assertIsTable, "hi there!") - assertFailure(lu.assertIsTable, nil) - lu.assertIsTable({}) - lu.assertIsTable({1,2,3}) - lu.assertIsTable({1}) - assertFailure(lu.assertIsTable, true) - assertFailure(lu.assertIsTable, coroutine.create( function(v) local y=v+1 end ) ) - end - - function TestLuaUnitAssertions:test_assertIsBoolean() - assertFailure(lu.assertIsBoolean, 1) - assertFailure(lu.assertIsBoolean, 1.4) - assertFailure(lu.assertIsBoolean, "hi there!") - assertFailure(lu.assertIsBoolean, nil) - assertFailure(lu.assertIsBoolean, {}) - assertFailure(lu.assertIsBoolean, {1,2,3}) - assertFailure(lu.assertIsBoolean, {1}) - assertFailure(lu.assertIsBoolean, coroutine.create( function(v) local y=v+1 end ) ) - lu.assertIsBoolean(true) - lu.assertIsBoolean(false) - end - - function TestLuaUnitAssertions:test_assertIsNil() - assertFailure(lu.assertIsNil, 1) - assertFailure(lu.assertIsNil, 1.4) - assertFailure(lu.assertIsNil, "hi there!") - lu.assertIsNil(nil) - assertFailure(lu.assertIsNil, {}) - assertFailure(lu.assertIsNil, {1,2,3}) - assertFailure(lu.assertIsNil, {1}) - assertFailure(lu.assertIsNil, false) - assertFailure(lu.assertIsNil, coroutine.create( function(v) local y=v+1 end ) ) - end - - function TestLuaUnitAssertions:test_assertIsFunction() - local f = function() return true end - - assertFailure(lu.assertIsFunction, 1) - assertFailure(lu.assertIsFunction, 1.4) - assertFailure(lu.assertIsFunction, "hi there!") - assertFailure(lu.assertIsFunction, nil) - assertFailure(lu.assertIsFunction, {}) - assertFailure(lu.assertIsFunction, {1,2,3}) - assertFailure(lu.assertIsFunction, {1}) - assertFailure(lu.assertIsFunction, false) - assertFailure(lu.assertIsFunction, coroutine.create( function(v) local y=v+1 end ) ) - lu.assertIsFunction(f) - end - - function TestLuaUnitAssertions:test_assertIsThread() - assertFailure(lu.assertIsThread, 1) - assertFailure(lu.assertIsThread, 1.4) - assertFailure(lu.assertIsThread, "hi there!") - assertFailure(lu.assertIsThread, nil) - assertFailure(lu.assertIsThread, {}) - assertFailure(lu.assertIsThread, {1,2,3}) - assertFailure(lu.assertIsThread, {1}) - assertFailure(lu.assertIsThread, false) - assertFailure(lu.assertIsThread, function(v) local y=v+1 end ) - lu.assertIsThread(coroutine.create( function(v) local y=v+1 end ) ) - end - - function TestLuaUnitAssertions:test_assertIsUserdata() - assertFailure(lu.assertIsUserdata, 1) - assertFailure(lu.assertIsUserdata, 1.4) - assertFailure(lu.assertIsUserdata, "hi there!") - assertFailure(lu.assertIsUserdata, nil) - assertFailure(lu.assertIsUserdata, {}) - assertFailure(lu.assertIsUserdata, {1,2,3}) - assertFailure(lu.assertIsUserdata, {1}) - assertFailure(lu.assertIsUserdata, false) - assertFailure(lu.assertIsUserdata, function(v) local y=v+1 end ) - assertFailure(lu.assertIsUserdata, coroutine.create( function(v) local y=v+1 end ) ) - end - - function TestLuaUnitAssertions:test_assertNotIsNumber() - assertFailure(lu.assertNotIsNumber, 1 ) - assertFailure(lu.assertNotIsNumber, 1.4 ) - lu.assertNotIsNumber( "hi there!") - lu.assertNotIsNumber( nil) - lu.assertNotIsNumber( {}) - lu.assertNotIsNumber( {1,2,3}) - lu.assertNotIsNumber( {1}) - lu.assertNotIsNumber( coroutine.create( function(v) local y=v+1 end ) ) - lu.assertNotIsNumber( true) - end - - function TestLuaUnitAssertions:test_assertNotIsNaN() - lu.assertNotIsNaN( "hi there!" ) - lu.assertNotIsNaN( nil ) - lu.assertNotIsNaN( {} ) - lu.assertNotIsNaN( {1,2,3} ) - lu.assertNotIsNaN( {1} ) - lu.assertNotIsNaN( coroutine.create( function(v) local y=v+1 end ) ) - assertFailure(lu.assertNotIsNaN, 0 / 0) - assertFailure(lu.assertNotIsNaN, -0 / 0) - assertFailure(lu.assertNotIsNaN, 0 / -0) - assertFailure(lu.assertNotIsNaN, -0 / -0) - local inf = math.huge - assertFailure(lu.assertNotIsNaN, inf / inf) - assertFailure(lu.assertNotIsNaN, -inf / inf) - assertFailure(lu.assertNotIsNaN, inf / -inf) - assertFailure(lu.assertNotIsNaN, -inf / -inf) - assertFailure(lu.assertNotIsNaN, inf - inf) - assertFailure(lu.assertNotIsNaN, (-inf) + inf) - assertFailure(lu.assertNotIsNaN, inf + (-inf)) - assertFailure(lu.assertNotIsNaN, (-inf) - (-inf)) - assertFailure(lu.assertNotIsNaN, 0 * inf) - assertFailure(lu.assertNotIsNaN, -0 * inf) - assertFailure(lu.assertNotIsNaN, 0 * -inf) - assertFailure(lu.assertNotIsNaN, -0 * -inf) - assertFailure(lu.assertNotIsNaN, math.sqrt(-1)) - if lu._LUAVERSION == "Lua 5.1" or lu._LUAVERSION == "Lua 5.2" then - -- Lua 5.3 will complain/error "bad argument #2 to 'fmod' (zero)" - assertFailure(lu.assertNotIsNaN, math.fmod(1, 0)) - assertFailure(lu.assertNotIsNaN, math.fmod(1, -0)) - end - assertFailure(lu.assertNotIsNaN, math.fmod(inf, 1)) - assertFailure(lu.assertNotIsNaN, math.fmod(-inf, 1)) - lu.assertNotIsNaN( 0 / 1 ) -- 0.0 - lu.assertNotIsNaN( 1 / 0 ) -- inf - end - - function TestLuaUnitAssertions:test_assertNotIsInf() - lu.assertNotIsInf( "hi there!" ) - lu.assertNotIsInf( nil) - lu.assertNotIsInf( {}) - lu.assertNotIsInf( {1,2,3}) - lu.assertNotIsInf( {1}) - lu.assertNotIsInf( coroutine.create( function(v) local y=v+1 end ) ) - lu.assertNotIsInf( 0 / 0 ) -- NaN - lu.assertNotIsInf( 0 / 1 ) -- 0.0 - assertFailure(lu.assertNotIsInf, 1 / 0 ) - assertFailure(lu.assertNotIsInf, math.log(0) ) - assertFailure(lu.assertNotIsInf, math.huge ) - assertFailure(lu.assertNotIsInf, -math.huge ) - end - - function TestLuaUnitAssertions:test_assertNotIsString() - lu.assertNotIsString( 1) - lu.assertNotIsString( 1.4) - assertFailure( lu.assertNotIsString, "hi there!") - lu.assertNotIsString( nil) - lu.assertNotIsString( {}) - lu.assertNotIsString( {1,2,3}) - lu.assertNotIsString( {1}) - lu.assertNotIsString( coroutine.create( function(v) local y=v+1 end ) ) - lu.assertNotIsString( true) - end - - function TestLuaUnitAssertions:test_assertNotIsTable() - lu.assertNotIsTable( 1) - lu.assertNotIsTable( 1.4) - lu.assertNotIsTable( "hi there!") - lu.assertNotIsTable( nil) - assertFailure( lu.assertNotIsTable, {}) - assertFailure( lu.assertNotIsTable, {1,2,3}) - assertFailure( lu.assertNotIsTable, {1}) - lu.assertNotIsTable( true) - lu.assertNotIsTable( coroutine.create( function(v) local y=v+1 end ) ) - end - - function TestLuaUnitAssertions:test_assertNotIsBoolean() - lu.assertNotIsBoolean( 1) - lu.assertNotIsBoolean( 1.4) - lu.assertNotIsBoolean( "hi there!") - lu.assertNotIsBoolean( nil) - lu.assertNotIsBoolean( {}) - lu.assertNotIsBoolean( {1,2,3}) - lu.assertNotIsBoolean( {1}) - lu.assertNotIsBoolean( coroutine.create( function(v) local y=v+1 end ) ) - assertFailure( lu.assertNotIsBoolean, true) - assertFailure( lu.assertNotIsBoolean, false) - end - - function TestLuaUnitAssertions:test_assertNotIsNil() - lu.assertNotIsNil( 1) - lu.assertNotIsNil( 1.4) - lu.assertNotIsNil( "hi there!") - assertFailure( lu.assertNotIsNil, nil) - lu.assertNotIsNil( {}) - lu.assertNotIsNil( {1,2,3}) - lu.assertNotIsNil( {1}) - lu.assertNotIsNil( false) - lu.assertNotIsNil( coroutine.create( function(v) local y=v+1 end ) ) - end - - function TestLuaUnitAssertions:test_assertNotIsFunction() - local f = function() return true end - - lu.assertNotIsFunction( 1) - lu.assertNotIsFunction( 1.4) - lu.assertNotIsFunction( "hi there!") - lu.assertNotIsFunction( nil) - lu.assertNotIsFunction( {}) - lu.assertNotIsFunction( {1,2,3}) - lu.assertNotIsFunction( {1}) - lu.assertNotIsFunction( false) - lu.assertNotIsFunction( coroutine.create( function(v) local y=v+1 end ) ) - assertFailure( lu.assertNotIsFunction, f) - end - - function TestLuaUnitAssertions:test_assertNotIsThread() - lu.assertNotIsThread( 1) - lu.assertNotIsThread( 1.4) - lu.assertNotIsThread( "hi there!") - lu.assertNotIsThread( nil) - lu.assertNotIsThread( {}) - lu.assertNotIsThread( {1,2,3}) - lu.assertNotIsThread( {1}) - lu.assertNotIsThread( false) - lu.assertNotIsThread( function(v) local y=v+1 end ) - assertFailure( lu.assertNotIsThread, coroutine.create( function(v) local y=v+1 end ) ) - end - - function TestLuaUnitAssertions:test_assertNotIsUserdata() - lu.assertNotIsUserdata( 1) - lu.assertNotIsUserdata( 1.4) - lu.assertNotIsUserdata( "hi there!") - lu.assertNotIsUserdata( nil) - lu.assertNotIsUserdata( {}) - lu.assertNotIsUserdata( {1,2,3}) - lu.assertNotIsUserdata( {1}) - lu.assertNotIsUserdata( false) - lu.assertNotIsUserdata( function(v) local y=v+1 end ) - lu.assertNotIsUserdata( coroutine.create( function(v) local y=v+1 end ) ) - end - - function TestLuaUnitAssertions:test_assertIs() - local f = function() return true end - local g = function() return true end - local t1= {} - local t2={1,2} - local t3={1,2} - local t4= {a=1,{1,2},day="today"} - local s1='toto' - local s2='toto' - local s3='to'..'to' - local b1=true - local b2=false - - lu.assertIs(1,1) - lu.assertIs(f,f) - lu.assertIs('toto', 'toto') - lu.assertIs(s1, s2) - lu.assertIs(s1, s3) - lu.assertIs(t1,t1) - lu.assertIs(t4,t4) - lu.assertIs(b1, true) - lu.assertIs(b2, false) - - assertFailure(lu.assertIs, 1, 2) - assertFailure(lu.assertIs, 1.4, 1) - assertFailure(lu.assertIs, "hi there!", "hola") - assertFailure(lu.assertIs, nil, 1) - assertFailure(lu.assertIs, {}, {}) - assertFailure(lu.assertIs, {1,2,3}, f) - assertFailure(lu.assertIs, f, g) - assertFailure(lu.assertIs, t2,t3 ) - assertFailure(lu.assertIs, b2, nil) - - -- tricky, table with protected metatable - local t5 = setmetatable( {1,2}, {__metatable='private'}) - local t6 = {1,2} - lu.assertIs(t5, t5) - assertFailure( lu.assertIs, t5, t6) - end - - function TestLuaUnitAssertions:test_assertNotIs() - local f = function() return true end - local g = function() return true end - local t1= {} - local t2={1,2} - local t3={1,2} - local t4= {a=1,{1,2},day="today"} - local s1='toto' - local s2='toto' - local b1=true - local b2=false - - assertFailure( lu.assertNotIs, 1,1 ) - assertFailure( lu.assertNotIs, f,f ) - assertFailure( lu.assertNotIs, t1,t1 ) - assertFailure( lu.assertNotIs, t4,t4) - assertFailure( lu.assertNotIs, s1,s2 ) - assertFailure( lu.assertNotIs, 'toto', 'toto' ) - assertFailure( lu.assertNotIs, b1, true ) - assertFailure( lu.assertNotIs, b2, false ) - - lu.assertNotIs(1, 2) - lu.assertNotIs(1.4, 1) - lu.assertNotIs("hi there!", "hola") - lu.assertNotIs(nil, 1) - lu.assertNotIs({}, {}) - lu.assertNotIs({1,2,3}, f) - lu.assertNotIs(f, g) - lu.assertNotIs(t2,t3) - lu.assertNotIs(b1, false) - lu.assertNotIs(b2, true) - lu.assertNotIs(b2, nil) - end - - function TestLuaUnitAssertions:test_assertTableNum() - lu.assertEquals( 3, 3 ) - lu.assertNotEquals( 3, 4 ) - lu.assertEquals( {3}, {3} ) - lu.assertNotEquals( {3}, 3 ) - lu.assertNotEquals( {3}, {4} ) - lu.assertEquals( {x=1}, {x=1} ) - lu.assertNotEquals( {x=1}, {x=2} ) - lu.assertNotEquals( {x=1}, {y=1} ) - end - function TestLuaUnitAssertions:test_assertTableStr() - lu.assertEquals( '3', '3' ) - lu.assertNotEquals( '3', '4' ) - lu.assertEquals( {'3'}, {'3'} ) - lu.assertNotEquals( {'3'}, '3' ) - lu.assertNotEquals( {'3'}, {'4'} ) - lu.assertEquals( {x='1'}, {x='1'} ) - lu.assertNotEquals( {x='1'}, {x='2'} ) - lu.assertNotEquals( {x='1'}, {y='1'} ) - end - function TestLuaUnitAssertions:test_assertTableLev2() - lu.assertEquals( {x={'a'}}, {x={'a'}} ) - lu.assertNotEquals( {x={'a'}}, {x={'b'}} ) - lu.assertNotEquals( {x={'a'}}, {z={'a'}} ) - lu.assertEquals( {{x=1}}, {{x=1}} ) - lu.assertNotEquals( {{x=1}}, {{y=1}} ) - lu.assertEquals( {{x='a'}}, {{x='a'}} ) - lu.assertNotEquals( {{x='a'}}, {{x='b'}} ) - end - function TestLuaUnitAssertions:test_assertTableList() - lu.assertEquals( {3,4,5}, {3,4,5} ) - lu.assertNotEquals( {3,4,5}, {3,4,6} ) - lu.assertNotEquals( {3,4,5}, {3,5,4} ) - lu.assertEquals( {3,4,x=5}, {3,4,x=5} ) - lu.assertNotEquals( {3,4,x=5}, {3,4,x=6} ) - lu.assertNotEquals( {3,4,x=5}, {3,x=4,5} ) - lu.assertNotEquals( {3,4,5}, {2,3,4,5} ) - lu.assertNotEquals( {3,4,5}, {3,2,4,5} ) - lu.assertNotEquals( {3,4,5}, {3,4,5,6} ) - end - - function TestLuaUnitAssertions:test_assertTableNil() - lu.assertEquals( {3,4,5}, {3,4,5} ) - lu.assertNotEquals( {3,4,5}, {nil,3,4,5} ) - lu.assertNotEquals( {3,4,5}, {nil,4,5} ) - lu.assertEquals( {3,4,5}, {3,4,5,nil} ) -- lua quirk - lu.assertNotEquals( {3,4,5}, {3,4,nil} ) - lu.assertNotEquals( {3,4,5}, {3,nil,5} ) - lu.assertNotEquals( {3,4,5}, {3,4,nil,5} ) - end - - function TestLuaUnitAssertions:test_assertTableNilFront() - lu.assertEquals( {nil,4,5}, {nil,4,5} ) - lu.assertNotEquals( {nil,4,5}, {nil,44,55} ) - lu.assertEquals( {nil,'4','5'}, {nil,'4','5'} ) - lu.assertNotEquals( {nil,'4','5'}, {nil,'44','55'} ) - lu.assertEquals( {nil,{4,5}}, {nil,{4,5}} ) - lu.assertNotEquals( {nil,{4,5}}, {nil,{44,55}} ) - lu.assertNotEquals( {nil,{4}}, {nil,{44}} ) - lu.assertEquals( {nil,{x=4,5}}, {nil,{x=4,5}} ) - lu.assertEquals( {nil,{x=4,5}}, {nil,{5,x=4}} ) -- lua quirk - lu.assertEquals( {nil,{x=4,y=5}}, {nil,{y=5,x=4}} ) -- lua quirk - lu.assertNotEquals( {nil,{x=4,5}}, {nil,{y=4,5}} ) - end - - function TestLuaUnitAssertions:test_assertTableAdditions() - lu.assertEquals( {1,2,3}, {1,2,3} ) - lu.assertNotEquals( {1,2,3}, {1,2,3,4} ) - lu.assertNotEquals( {1,2,3,4}, {1,2,3} ) - lu.assertEquals( {1,x=2,3}, {1,x=2,3} ) - lu.assertNotEquals( {1,x=2,3}, {1,x=2,3,y=4} ) - lu.assertNotEquals( {1,x=2,3,y=4}, {1,x=2,3} ) - end - - function TestLuaUnitAssertions:test_assertTableProtectedMt() - -- tricky, table with protected metatable - local t1 = setmetatable( {1,2}, {__metatable='private'}) - local t2 = {1,2} - local t3 = setmetatable( {1,2}, {__metatable='private'}) - - lu.assertEquals(t1, t2) - lu.assertEquals(t2, t3) - end - -local function assertFailureEquals(msg, ...) - lu.assertErrorMsgEquals(lu.FAILURE_PREFIX .. msg, ...) -end - -local function assertFailureMatches(msg, ...) - lu.assertErrorMsgMatches(lu.FAILURE_PREFIX .. msg, ...) -end - -local function assertFailureContains(msg, ...) - lu.assertErrorMsgContains(lu.FAILURE_PREFIX .. msg, ...) -end - -TestLuaUnitAssertionsError = {} - - function TestLuaUnitAssertionsError:setUp() - self.f = function ( v ) - local y = v + 1 - end - self.f_with_error = function (v) - local y = v + 2 - error('This is an error', 2) - end - - self.f_with_table_error = function (v) - local y = v + 2 - local ts = { __tostring = function() return 'This table has error!' end } - -- the error message is a table which converts to string - error( setmetatable( { this_table="has error" }, ts ) ) - end - - - end - - function TestLuaUnitAssertionsError:test_assertError() - local x = 1 - - -- f_with_error generates an error - local has_error = not pcall( self.f_with_error, x ) - lu.assertEquals( has_error, true ) - - -- f does not generate an error - has_error = not pcall( self.f, x ) - lu.assertEquals( has_error, false ) - - -- lu.assertError is happy with f_with_error - lu.assertError( self.f_with_error, x ) - - -- lu.assertError is unhappy with f - assertFailureEquals( "Expected an error when calling function but no error generated", - lu.assertError, self.f, x ) - - -- multiple arguments - local function f_with_multi_arguments(a,b,c) - if a == b and b == c then return end - error("three arguments not equal") - end - - lu.assertError( f_with_multi_arguments, 1, 1, 3 ) - lu.assertError( f_with_multi_arguments, 1, 3, 1 ) - lu.assertError( f_with_multi_arguments, 3, 1, 1 ) - - assertFailureEquals( "Expected an error when calling function but no error generated", - lu.assertError, f_with_multi_arguments, 1, 1, 1 ) - - -- error generated as table - lu.assertError( self.f_with_table_error, 1 ) - - end - - function TestLuaUnitAssertionsError:test_assertErrorMsgContains() - local x = 1 - assertFailure( lu.assertErrorMsgContains, 'toto', self.f, x ) - lu.assertErrorMsgContains( 'is an err', self.f_with_error, x ) - lu.assertErrorMsgContains( 'This is an error', self.f_with_error, x ) - assertFailure( lu.assertErrorMsgContains, ' This is an error', self.f_with_error, x ) - assertFailure( lu.assertErrorMsgContains, 'This .. an error', self.f_with_error, x ) - lu.assertErrorMsgContains("50", function() error(500) end) - - -- error message is a table which converts to a string - lu.assertErrorMsgContains( 'This table has error', self.f_with_table_error, 1 ) - end - - function TestLuaUnitAssertionsError:test_assertErrorMsgEquals() - local x = 1 - assertFailure( lu.assertErrorMsgEquals, 'toto', self.f, x ) - assertFailure( lu.assertErrorMsgEquals, 'is an err', self.f_with_error, x ) - - -- expected string, receive string - lu.assertErrorMsgEquals( 'This is an error', self.f_with_error, x ) - - -- expected table, receive table - lu.assertErrorMsgEquals({1,2,3,4}, function() error({1,2,3,4}) end) - - -- expected complex table, receive complex table - lu.assertErrorMsgEquals({ - details = {1,2,3,4}, - id = 10, - }, function() error({ - details = {1,2,3,4}, - id = 10, - }) end) - - -- expected string, receive number converted to string - lu.assertErrorMsgEquals("500", function() error(500, 2) end) - - -- one space added at the beginning - assertFailure( lu.assertErrorMsgEquals, ' This is an error', self.f_with_error, x ) - - -- pattern does not work - assertFailure( lu.assertErrorMsgEquals, 'This .. an error', self.f_with_error, x ) - - -- expected string, receive table which converts to string - lu.assertErrorMsgEquals( "This table has error!", self.f_with_table_error, x) - - -- expected table, no error generated - assertFailure( lu.assertErrorMsgEquals, { 1 }, function( v ) return "{ 1 }" end, 33 ) - - -- expected table, error generated as string, no match - assertFailure( lu.assertErrorMsgEquals, { 1 }, function( v ) error( "{ 1 }" ) end, 33 ) - end - - function TestLuaUnitAssertionsError:test_assertErrorMsgMatches() - local x = 1 - assertFailure( lu.assertErrorMsgMatches, 'toto', self.f, x ) - assertFailure( lu.assertErrorMsgMatches, 'is an err', self.f_with_error, x ) - lu.assertErrorMsgMatches( 'This is an error', self.f_with_error, x ) - lu.assertErrorMsgMatches( 'This is .. error', self.f_with_error, x ) - lu.assertErrorMsgMatches(".*500$", function() error(500, 2) end) - lu.assertErrorMsgMatches("This .* has error!", self.f_with_table_error, 33 ) - - -- one space added to cause failure - assertFailure( lu.assertErrorMsgMatches, ' This is an error', self.f_with_error, x ) - assertFailure( lu.assertErrorMsgMatches, "This", self.f_with_table_error, 33 ) - - - - end - ------------------------------------------------------------------- --- --- Failure message tests --- ------------------------------------------------------------------- - -TestLuaUnitErrorMsg = { __class__ = 'TestLuaUnitErrorMsg' } - - function TestLuaUnitErrorMsg:setUp() - self.old_ORDER_ACTUAL_EXPECTED = lu.ORDER_ACTUAL_EXPECTED - self.old_PRINT_TABLE_REF_IN_ERROR_MSG = lu.PRINT_TABLE_REF_IN_ERROR_MSG - end - - function TestLuaUnitErrorMsg:tearDown() - lu.ORDER_ACTUAL_EXPECTED = self.old_ORDER_ACTUAL_EXPECTED - lu.PRINT_TABLE_REF_IN_ERROR_MSG = self.old_PRINT_TABLE_REF_IN_ERROR_MSG - end - - function TestLuaUnitErrorMsg:test_adjust_err_msg_with_iter() - local err_msg, status - - --------------- FAIL --------------------- - -- file-line info, strip failure prefix, no iteration info - err_msg, status = lu.adjust_err_msg_with_iter( - '.\\test\\test_luaunit.lua:2247: LuaUnit test FAILURE: Expected an error when calling function but no error generated', - nil ) - lu.assertEquals( { err_msg, status }, - { '.\\test\\test_luaunit.lua:2247: Expected an error when calling function but no error generated', - lu.NodeStatus.FAIL } ) - - -- file-line info, strip failure prefix, with iteration info - err_msg, status = lu.adjust_err_msg_with_iter( - '.\\test\\test_luaunit.lua:2247: LuaUnit test FAILURE: Expected an error when calling function but no error generated', - 'iteration 33' ) - lu.assertEquals( { err_msg, status }, - { '.\\test\\test_luaunit.lua:2247: iteration 33, Expected an error when calling function but no error generated', - lu.NodeStatus.FAIL } ) - - -- no file-line info, strip failure prefix, no iteration info - err_msg, status = lu.adjust_err_msg_with_iter( - 'LuaUnit test FAILURE: Expected an error when calling function but no error generated', - nil ) - lu.assertEquals( { err_msg, status }, - { 'Expected an error when calling function but no error generated', - lu.NodeStatus.FAIL } ) - - -- no file-line info, strip failure prefix, with iteration info - err_msg, status = lu.adjust_err_msg_with_iter( - 'LuaUnit test FAILURE: Expected an error when calling function but no error generated', - 'iteration 33' ) - lu.assertEquals( { err_msg, status }, - { 'iteration 33, Expected an error when calling function but no error generated', - lu.NodeStatus.FAIL } ) - - --------------- ERROR --------------------- - -- file-line info, pure error, no iteration info, do nothing - err_msg, status = lu.adjust_err_msg_with_iter( - '.\\test\\test_luaunit.lua:2723: teardown error', - nil ) - lu.assertEquals( { err_msg, status }, - { '.\\test\\test_luaunit.lua:2723: teardown error', - lu.NodeStatus.ERROR } ) - - -- file-line info, pure error, add iteration info - err_msg, status = lu.adjust_err_msg_with_iter( - '.\\test\\test_luaunit.lua:2723: teardown error', - 'iteration 33' ) - lu.assertEquals( { err_msg, status }, - { '.\\test\\test_luaunit.lua:2723: iteration 33, teardown error', - lu.NodeStatus.ERROR } ) - - -- no file-line info, pure error, no iteration info, do nothing - err_msg, status = lu.adjust_err_msg_with_iter( - 'teardown error', - nil ) - lu.assertEquals( { err_msg, status }, - { 'teardown error', - lu.NodeStatus.ERROR } ) - - -- no file-line info, pure error, add iteration info - err_msg, status = lu.adjust_err_msg_with_iter( - 'teardown error', - 'iteration 33' ) - lu.assertEquals( { err_msg, status }, - { 'iteration 33, teardown error', - lu.NodeStatus.ERROR } ) - - --------------- PASS --------------------- - -- file-line info, success, return empty error message - err_msg, status = lu.adjust_err_msg_with_iter( - '.\\test\\test_luaunit.lua:2247: LuaUnit test SUCCESS: the test did actually work !', - nil ) - lu.assertEquals( { err_msg, status }, - { nil, lu.NodeStatus.SUCCESS } ) - - -- file-line info, success, return empty error message, even with iteration - err_msg, status = lu.adjust_err_msg_with_iter( - '.\\test\\test_luaunit.lua:2247: LuaUnit test SUCCESS: the test did actually work !', - 'iteration 33' ) - lu.assertEquals( { err_msg, status }, - { nil, lu.NodeStatus.SUCCESS } ) - - -- no file-line info, success, return empty error message - err_msg, status = lu.adjust_err_msg_with_iter( - 'LuaUnit test SUCCESS: the test did actually work !', - nil ) - lu.assertEquals( { err_msg, status }, - { nil, lu.NodeStatus.SUCCESS } ) - - -- no file-line info, success, return empty error message, even with iteration - err_msg, status = lu.adjust_err_msg_with_iter( - 'LuaUnit test SUCCESS: the test did actually work !', - 'iteration 33' ) - lu.assertEquals( { err_msg, status }, - { nil, lu.NodeStatus.SUCCESS } ) - - end - - - function TestLuaUnitErrorMsg:test_assertEqualsMsg() - assertFailureEquals( 'expected: 2, actual: 1', lu.assertEquals, 1, 2 ) - assertFailureEquals( 'expected: "exp"\nactual: "act"', lu.assertEquals, 'act', 'exp' ) - assertFailureEquals( 'expected: \n"exp\npxe"\nactual: \n"act\ntca"', lu.assertEquals, 'act\ntca', 'exp\npxe' ) - assertFailureEquals( 'expected: true, actual: false', lu.assertEquals, false, true ) - assertFailureEquals( 'expected: 1.2, actual: 1', lu.assertEquals, 1, 1.2) - assertFailureMatches( 'expected: {1, 2}\nactual: {2, 1}', lu.assertEquals, {2,1}, {1,2} ) - assertFailureMatches( 'expected: {one=1, two=2}\nactual: {3, 2, 1}', lu.assertEquals, {3,2,1}, {one=1,two=2} ) - assertFailureEquals( 'expected: 2, actual: nil', lu.assertEquals, nil, 2 ) - assertFailureEquals( 'toto\nexpected: 2, actual: nil', lu.assertEquals, nil, 2, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertEqualsOrderReversedMsg() - lu.ORDER_ACTUAL_EXPECTED = false - assertFailureEquals( 'expected: 1, actual: 2', lu.assertEquals, 1, 2 ) - assertFailureEquals( 'expected: "act"\nactual: "exp"', lu.assertEquals, 'act', 'exp' ) - end - - function TestLuaUnitErrorMsg:test_assertAlmostEqualsMsg() - assertFailureEquals('Values are not almost equal\nActual: 2, expected: 1, delta 1 above margin of 0.1', lu.assertAlmostEquals, 2, 1, 0.1 ) - assertFailureEquals('toto\nValues are not almost equal\nActual: 2, expected: 1, delta 1 above margin of 0.1', lu.assertAlmostEquals, 2, 1, 0.1, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertAlmostEqualsOrderReversedMsg() - lu.ORDER_ACTUAL_EXPECTED = false - assertFailureEquals('Values are not almost equal\nActual: 1, expected: 2, delta 1 above margin of 0.1', lu.assertAlmostEquals, 2, 1, 0.1 ) - end - - function TestLuaUnitErrorMsg:test_assertNotAlmostEqualsMsg() - -- single precision math Lua won't output an "exact" delta (0.1) here, so we do a partial match - assertFailureContains('Values are almost equal\nActual: 1.1, expected: 1, delta 0.1 below margin of 0.2', lu.assertNotAlmostEquals, 1.1, 1, 0.2 ) - assertFailureContains('toto\nValues are almost equal\nActual: 1.1, expected: 1, delta 0.1 below margin of 0.2', lu.assertNotAlmostEquals, 1.1, 1, 0.2, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotAlmostEqualsOrderReversedMsg() - -- single precision math Lua won't output an "exact" delta (0.1) here, so we do a partial match - lu.ORDER_ACTUAL_EXPECTED = false - assertFailureContains('Values are almost equal\nActual: 1, expected: 1.1, delta 0.1 below margin of 0.2', lu.assertNotAlmostEquals, 1.1, 1, 0.2 ) - end - - function TestLuaUnitErrorMsg:test_assertNotEqualsMsg() - assertFailureEquals( 'Received the not expected value: 1', lu.assertNotEquals, 1, 1 ) - assertFailureMatches( 'Received the not expected value: {1, 2}', lu.assertNotEquals, {1,2}, {1,2} ) - assertFailureEquals( 'Received the not expected value: nil', lu.assertNotEquals, nil, nil ) - assertFailureEquals( 'toto\nReceived the not expected value: 1', lu.assertNotEquals, 1, 1, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotEqualsOrderReversedMsg() - lu.ORDER_ACTUAL_EXPECTED = false - assertFailureEquals( 'Received the not expected value: 1', lu.assertNotEquals, 1, 1 ) - end - - function TestLuaUnitErrorMsg:test_assertTrueFalse() - assertFailureEquals( 'expected: true, actual: false', lu.assertTrue, false ) - assertFailureEquals( 'expected: true, actual: nil', lu.assertTrue, nil ) - assertFailureEquals( 'expected: false, actual: true', lu.assertFalse, true ) - assertFailureEquals( 'expected: false, actual: nil', lu.assertFalse, nil ) - assertFailureEquals( 'expected: false, actual: 0', lu.assertFalse, 0) - assertFailureMatches( 'expected: false, actual: {}', lu.assertFalse, {}) - assertFailureEquals( 'expected: false, actual: "abc"', lu.assertFalse, 'abc') - assertFailureContains( 'expected: false, actual: function', lu.assertFalse, function () end ) - - assertFailureEquals( 'toto\nexpected: true, actual: false', lu.assertTrue, false, 'toto' ) - assertFailureEquals( 'toto\nexpected: false, actual: 0', lu.assertFalse, 0, 'toto') - end - - function TestLuaUnitErrorMsg:test_assertEvalToTrueFalse() - assertFailureEquals( 'expected: a value evaluating to true, actual: false', lu.assertEvalToTrue, false ) - assertFailureEquals( 'expected: a value evaluating to true, actual: nil', lu.assertEvalToTrue, nil ) - assertFailureEquals( 'expected: false or nil, actual: true', lu.assertEvalToFalse, true ) - assertFailureEquals( 'expected: false or nil, actual: 0', lu.assertEvalToFalse, 0) - assertFailureMatches( 'expected: false or nil, actual: {}', lu.assertEvalToFalse, {}) - assertFailureEquals( 'expected: false or nil, actual: "abc"', lu.assertEvalToFalse, 'abc') - assertFailureContains( 'expected: false or nil, actual: function', lu.assertEvalToFalse, function () end ) - assertFailureEquals( 'toto\nexpected: a value evaluating to true, actual: false', lu.assertEvalToTrue, false, 'toto' ) - assertFailureEquals( 'toto\nexpected: false or nil, actual: 0', lu.assertEvalToFalse, 0, 'toto') - end - - function TestLuaUnitErrorMsg:test_assertNil() - assertFailureEquals( 'expected: nil, actual: false', lu.assertNil, false ) - assertFailureEquals( 'toto\nexpected: nil, actual: false', lu.assertNil, false, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotNil() - assertFailureEquals( 'expected: not nil, actual: nil', lu.assertNotNil, nil ) - assertFailureEquals( 'toto\nexpected: not nil, actual: nil', lu.assertNotNil, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertStrContains() - assertFailureEquals( 'Could not find substring "xxx" in string "abcdef"', lu.assertStrContains, 'abcdef', 'xxx' ) - assertFailureEquals( 'Could not find substring "aBc" in string "abcdef"', lu.assertStrContains, 'abcdef', 'aBc' ) - assertFailureEquals( 'Could not find substring "xxx" in string ""', lu.assertStrContains, '', 'xxx' ) - - assertFailureEquals( 'Could not find substring "xxx" in string "abcdef"', lu.assertStrContains, 'abcdef', 'xxx', false ) - assertFailureEquals( 'Could not find substring "aBc" in string "abcdef"', lu.assertStrContains, 'abcdef', 'aBc', false ) - assertFailureEquals( 'Could not find substring "xxx" in string ""', lu.assertStrContains, '', 'xxx', false ) - - assertFailureEquals( 'Could not find pattern "xxx" in string "abcdef"', lu.assertStrContains, 'abcdef', 'xxx', true ) - assertFailureEquals( 'Could not find pattern "aBc" in string "abcdef"', lu.assertStrContains, 'abcdef', 'aBc', true ) - assertFailureEquals( 'Could not find pattern "xxx" in string ""', lu.assertStrContains, '', 'xxx', true ) - - assertFailureEquals( 'toto\nCould not find pattern "xxx" in string ""', lu.assertStrContains, '', 'xxx', true, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertStrIContains() - assertFailureEquals( 'Could not find (case insensitively) substring "xxx" in string "abcdef"', lu.assertStrIContains, 'abcdef', 'xxx' ) - assertFailureEquals( 'Could not find (case insensitively) substring "xxx" in string ""', lu.assertStrIContains, '', 'xxx' ) - - assertFailureEquals( 'toto\nCould not find (case insensitively) substring "xxx" in string "abcdef"', lu.assertStrIContains, 'abcdef', 'xxx', 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotStrContains() - assertFailureEquals( 'Found the not expected substring "abc" in string "abcdef"', lu.assertNotStrContains, 'abcdef', 'abc' ) - assertFailureEquals( 'Found the not expected substring "abc" in string "abcdef"', lu.assertNotStrContains, 'abcdef', 'abc', false ) - assertFailureEquals( 'Found the not expected pattern "..." in string "abcdef"', lu.assertNotStrContains, 'abcdef', '...', true) - - assertFailureEquals( 'toto\nFound the not expected substring "abc" in string "abcdef"', lu.assertNotStrContains, 'abcdef', 'abc', false, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotStrIContains() - assertFailureEquals( 'Found (case insensitively) the not expected substring "aBc" in string "abcdef"', lu.assertNotStrIContains, 'abcdef', 'aBc' ) - assertFailureEquals( 'Found (case insensitively) the not expected substring "abc" in string "abcdef"', lu.assertNotStrIContains, 'abcdef', 'abc' ) - assertFailureEquals( 'toto\nFound (case insensitively) the not expected substring "abc" in string "abcdef"', lu.assertNotStrIContains, 'abcdef', 'abc', 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertStrMatches() - assertFailureEquals('Could not match pattern "xxx" with string "abcdef"', lu.assertStrMatches, 'abcdef', 'xxx' ) - assertFailureEquals('toto\nCould not match pattern "xxx" with string "abcdef"', lu.assertStrMatches, 'abcdef', 'xxx', nil, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsNumber() - assertFailureEquals( 'expected: a number value, actual: type string, value "abc"', lu.assertIsNumber, 'abc' ) - assertFailureEquals( 'expected: a number value, actual: nil', lu.assertIsNumber, nil ) - assertFailureEquals( 'toto\nexpected: a number value, actual: type string, value "abc"', lu.assertIsNumber, 'abc', 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsString() - assertFailureEquals( 'expected: a string value, actual: type number, value 1.2', lu.assertIsString, 1.2 ) - assertFailureEquals( 'expected: a string value, actual: nil', lu.assertIsString, nil ) - assertFailureEquals( 'toto\nexpected: a string value, actual: nil', lu.assertIsString, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsTable() - assertFailureEquals( 'expected: a table value, actual: type number, value 1.2', lu.assertIsTable, 1.2 ) - assertFailureEquals( 'expected: a table value, actual: nil', lu.assertIsTable, nil ) - assertFailureEquals( 'toto\nexpected: a table value, actual: nil', lu.assertIsTable, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsBoolean() - assertFailureEquals( 'expected: a boolean value, actual: type number, value 1.2', lu.assertIsBoolean, 1.2 ) - assertFailureEquals( 'expected: a boolean value, actual: nil', lu.assertIsBoolean, nil ) - assertFailureEquals( 'toto\nexpected: a boolean value, actual: nil', lu.assertIsBoolean, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsFunction() - assertFailureEquals( 'expected: a function value, actual: type number, value 1.2', lu.assertIsFunction, 1.2 ) - assertFailureEquals( 'expected: a function value, actual: nil', lu.assertIsFunction, nil ) - assertFailureEquals( 'toto\nexpected: a function value, actual: nil', lu.assertIsFunction, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsThread() - assertFailureEquals( 'expected: a thread value, actual: type number, value 1.2', lu.assertIsThread, 1.2 ) - assertFailureEquals( 'expected: a thread value, actual: nil', lu.assertIsThread, nil ) - assertFailureEquals( 'toto\nexpected: a thread value, actual: nil', lu.assertIsThread, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsUserdata() - assertFailureEquals( 'expected: a userdata value, actual: type number, value 1.2', lu.assertIsUserdata, 1.2 ) - assertFailureEquals( 'expected: a userdata value, actual: nil', lu.assertIsUserdata, nil ) - assertFailureEquals( 'toto\nexpected: a userdata value, actual: nil', lu.assertIsUserdata, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsNan() - assertFailureEquals( 'expected: NaN, actual: 33', lu.assertIsNaN, 33 ) - assertFailureEquals( 'toto\nexpected: NaN, actual: 33', lu.assertIsNaN, 33, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsNan() - assertFailureEquals( 'expected: not NaN, actual: NaN', lu.assertNotIsNaN, 0 / 0 ) - assertFailureEquals( 'toto\nexpected: not NaN, actual: NaN', lu.assertNotIsNaN, 0 / 0, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsInf() - assertFailureEquals( 'expected: #Inf, actual: 33', lu.assertIsInf, 33 ) - assertFailureEquals( 'toto\nexpected: #Inf, actual: 33', lu.assertIsInf, 33, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsPlusInf() - assertFailureEquals( 'expected: #Inf, actual: 33', lu.assertIsPlusInf, 33 ) - assertFailureEquals( 'toto\nexpected: #Inf, actual: 33', lu.assertIsPlusInf, 33, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsMinusInf() - assertFailureEquals( 'expected: -#Inf, actual: 33', lu.assertIsMinusInf, 33 ) - assertFailureEquals( 'toto\nexpected: -#Inf, actual: 33', lu.assertIsMinusInf, 33, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsInf() - assertFailureEquals( 'expected: not infinity, actual: #Inf', lu.assertNotIsInf, 1 / 0 ) - assertFailureEquals( 'toto\nexpected: not infinity, actual: -#Inf', lu.assertNotIsInf, -1 / 0, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsPlusInf() - assertFailureEquals( 'expected: not #Inf, actual: #Inf', lu.assertNotIsPlusInf, 1 / 0 ) - assertFailureEquals( 'toto\nexpected: not #Inf, actual: #Inf', lu.assertNotIsPlusInf, 1 / 0, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsMinusInf() - assertFailureEquals( 'expected: not -#Inf, actual: -#Inf', lu.assertNotIsMinusInf, -1 / 0 ) - assertFailureEquals( 'toto\nexpected: not -#Inf, actual: -#Inf', lu.assertNotIsMinusInf, -1 / 0, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsPlusZero() - assertFailureEquals( 'expected: +0.0, actual: 33', lu.assertIsPlusZero, 33 ) - assertFailureEquals( 'toto\nexpected: +0.0, actual: 33', lu.assertIsPlusZero, 33, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertIsMinusZero() - assertFailureEquals( 'expected: -0.0, actual: 33', lu.assertIsMinusZero, 33 ) - assertFailureEquals( 'toto\nexpected: -0.0, actual: 33', lu.assertIsMinusZero, 33, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsPlusZero() - assertFailureEquals( 'expected: not +0.0, actual: +0.0', lu.assertNotIsPlusZero, 0 ) - assertFailureEquals( 'toto\nexpected: not +0.0, actual: +0.0', lu.assertNotIsPlusZero, 0, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsMinusZero() - local minusZero = -1 / (1/0) - assertFailureEquals( 'expected: not -0.0, actual: -0.0', lu.assertNotIsMinusZero, minusZero ) - assertFailureEquals( 'toto\nexpected: not -0.0, actual: -0.0', lu.assertNotIsMinusZero, minusZero, 'toto' ) - end - - - function TestLuaUnitErrorMsg:test_assertNotIsTrue() - assertFailureEquals('expected: not true, actual: true', lu.assertNotIsTrue, true ) - assertFailureEquals('toto\nexpected: not true, actual: true', lu.assertNotIsTrue, true, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsFalse() - assertFailureEquals('expected: not false, actual: false', lu.assertNotIsFalse, false ) - assertFailureEquals('toto\nexpected: not false, actual: false', lu.assertNotIsFalse, false, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsNil() - assertFailureEquals( - 'expected: not nil, actual: nil', - lu.assertNotIsNil, nil ) - assertFailureEquals( - 'toto\nexpected: not nil, actual: nil', - lu.assertNotIsNil, nil, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsNumber() - assertFailureEquals( 'expected: not a number type, actual: value 123', lu.assertNotIsNumber, 123 ) - assertFailureEquals( 'toto\nexpected: not a number type, actual: value 123', lu.assertNotIsNumber, 123, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsString() - assertFailureEquals( 'expected: not a string type, actual: value "abc"', lu.assertNotIsString, "abc" ) - assertFailureEquals( 'toto\nexpected: not a string type, actual: value "abc"', lu.assertNotIsString, "abc", 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsTable() - assertFailureEquals( 'expected: not a table type, actual: value {1, 2, 3}', lu.assertNotIsTable, {1,2,3} ) - assertFailureEquals( 'toto\nexpected: not a table type, actual: value {1, 2, 3}', lu.assertNotIsTable, {1,2,3}, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsBoolean() - assertFailureEquals( 'expected: not a boolean type, actual: value false', lu.assertNotIsBoolean, false ) - assertFailureEquals( 'toto\nexpected: not a boolean type, actual: value false', lu.assertNotIsBoolean, false, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsFunction() - assertFailureContains( 'expected: not a function type, actual: value function:', lu.assertNotIsFunction, function() return true end ) - assertFailureContains( 'toto\nexpected: not a function type, actual: value function:', lu.assertNotIsFunction, function() return true end, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIsThread() - assertFailureContains( 'expected: not a thread type, actual: value thread:', lu.assertNotIsThread, coroutine.create( function(v) local y=v+1 end ) ) - assertFailureContains( 'toto\nexpected: not a thread type, actual: value thread:', lu.assertNotIsThread, coroutine.create( function(v) local y=v+1 end ), 'toto' ) - end - - --[[ How do you create UserData ? - function TestLuaUnitErrorMsg:test_assertIsNotUserdata() - assertFailureEquals( 'Not expected: a userdata type, actual: value XXX ???', lu.assertIsNotUserdata, XXX ??? ) - end - ]] - - function TestLuaUnitErrorMsg:test_assertIs() - assertFailureEquals( 'expected and actual object should not be different\nExpected: 1\nReceived: 2', lu.assertIs, 2, 1 ) - assertFailureMatches( 'expected and actual object should not be different\n'.. - 'Expected: <'..TABLE_IDX_REF_PAT..'> {1, 2, 3, 4, 5, 6, 7, 8}\n'.. - 'Received: <'..TABLE_IDX_REF_PAT..'> {1, 2, 3, 4, 5, 6, 7, 8}', - lu.assertIs, {1,2,3,4,5,6,7,8}, {1,2,3,4,5,6,7,8} ) - lu.ORDER_ACTUAL_EXPECTED = false - assertFailureEquals( 'expected and actual object should not be different\nExpected: 2\nReceived: 1', lu.assertIs, 2, 1 ) - assertFailureEquals( 'toto\nexpected and actual object should not be different\nExpected: 2\nReceived: 1', lu.assertIs, 2, 1, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertNotIs() - local v = {1,2} - assertFailureMatches( 'expected and actual object should be different: <'..TABLE_IDX_REF_PAT..'> {1, 2}', lu.assertNotIs, v, v ) - lu.ORDER_ACTUAL_EXPECTED = false -- order shouldn't matter here, but let's cover it - assertFailureMatches( 'expected and actual object should be different: <'..TABLE_IDX_REF_PAT..'> {1, 2}', lu.assertNotIs, v, v ) - assertFailureMatches( 'toto\nexpected and actual object should be different: <'..TABLE_IDX_REF_PAT..'> {1, 2}', lu.assertNotIs, v, v, 'toto' ) - end - - function TestLuaUnitErrorMsg:test_assertItemsEquals() - assertFailureMatches('Content of the tables are not identical:\nExpected: {one=2, two=3}\nActual: {1, 2}' , lu.assertItemsEquals, {1,2}, {one=2, two=3} ) - assertFailureContains('Content of the tables are not identical' , lu.assertItemsEquals, {}, {1} ) -- actual table empty, = doesn't contain expected value - assertFailureContains('Content of the tables are not identical' , lu.assertItemsEquals, nil, 'foobar' ) -- type mismatch - assertFailureContains('Content of the tables are not identical' , lu.assertItemsEquals, 'foo', 'bar' ) -- value mismatch - assertFailureContains('toto\nContent of the tables are not identical' , lu.assertItemsEquals, 'foo', 'bar', 'toto' ) -- value mismatch - end - - function TestLuaUnitErrorMsg:test_assertError() - assertFailureEquals('Expected an error when calling function but no error generated' , lu.assertError, function( v ) local y = v+1 end, 3 ) - end - - function TestLuaUnitErrorMsg:test_assertErrorMsgEquals() - assertFailureEquals('No error generated when calling function but expected error: "bla bla bla"' , - lu.assertErrorMsgEquals, 'bla bla bla', function( v ) local y = v+1 end, 3 ) - assertFailureEquals('Error message expected: "bla bla bla"\n' .. - 'Error message received: "toto xxx"\n' , - lu.assertErrorMsgEquals, 'bla bla bla', function( v ) error('toto xxx',2) end, 3 ) - assertFailureEquals('Error message expected: {1, 2, 3, 4}\nError message received: {1, 2, 3}\n' , - lu.assertErrorMsgEquals, {1,2,3,4}, function( v ) error(v) end, {1,2,3}) - assertFailureEquals('Error message expected: {details="bla bla bla"}\nError message received: {details="ble ble ble"}\n' , - lu.assertErrorMsgEquals, {details="bla bla bla"}, function( v ) error(v) end, {details="ble ble ble"}) - end - - function TestLuaUnitErrorMsg:test_assertErrorMsgContains() - assertFailureEquals('No error generated when calling function but expected error containing: "bla bla bla"' , - lu.assertErrorMsgContains, 'bla bla bla', function( v ) local y = v+1 end, 3 ) - assertFailureEquals('Error message does not contain: "bla bla bla"\nError message received: "toto xxx"\n' , - lu.assertErrorMsgContains, 'bla bla bla', function( v ) error('toto xxx',2) end, 3 ) - end - - function TestLuaUnitErrorMsg:test_assertErrorMsgMatches() - assertFailureEquals('No error generated when calling function but expected error matching: "bla bla bla"' , - lu.assertErrorMsgMatches, 'bla bla bla', function( v ) local y = v+1 end, 3 ) - - assertFailureEquals('Error message does not match pattern: "bla bla bla"\n' .. - 'Error message received: "toto xxx"\n' , - lu.assertErrorMsgMatches, 'bla bla bla', function( v ) error('toto xxx',2) end, 3 ) - end - - function TestLuaUnitErrorMsg:test_assertErrorMsgContentEquals() - local f = function() error("This is error message") end - lu.assertErrorMsgContentEquals("This is error message", f) - local f1 = function(v1, v2) error("This is error message") end - lu.assertErrorMsgContentEquals("This is error message", f, 1, 2) - end - - function TestLuaUnitErrorMsg:test_printTableWithRef() - lu.PRINT_TABLE_REF_IN_ERROR_MSG = true - assertFailureMatches( 'Received the not expected value: <'..TABLE_IDX_REF_PAT..'> {1, 2}', lu.assertNotEquals, {1,2}, {1,2} ) - -- trigger multiline prettystr - assertFailureMatches( 'Received the not expected value: <'..TABLE_IDX_REF_PAT..'> {1, 2, 3, 4}', lu.assertNotEquals, {1,2,3,4}, {1,2,3,4} ) - assertFailureMatches( 'expected: false, actual: <'..TABLE_IDX_REF_PAT..'> {}', lu.assertFalse, {}) - local v = {1,2} - assertFailureMatches( 'expected and actual object should be different: <'..TABLE_IDX_REF_PAT..'> {1, 2}', lu.assertNotIs, v, v ) - assertFailureMatches('Content of the tables are not identical:\nExpected: <'..TABLE_IDX_REF_PAT..'> {one=2, two=3}\nActual: <'..TABLE_IDX_REF_PAT..'> {1, 2}' , lu.assertItemsEquals, {1,2}, {one=2, two=3} ) - assertFailureMatches( 'expected: <'..TABLE_IDX_REF_PAT..'> {1, 2}\nactual: <'..TABLE_IDX_REF_PAT..'> {2, 1}', lu.assertEquals, {2,1}, {1,2} ) - -- trigger multiline prettystr - assertFailureMatches( 'expected: <'..TABLE_IDX_REF_PAT..'> {one=1, two=2}\nactual: <'..TABLE_IDX_REF_PAT..'> {3, 2, 1}', lu.assertEquals, {3,2,1}, {one=1,two=2} ) - -- trigger mismatch formatting - lu.assertErrorMsgContains( [[lists <table ]] , lu.assertEquals, {3,2,1,4,1,1,1,1,1,1,1}, {1,2,3,4,1,1,1,1,1,1,1} ) - lu.assertErrorMsgContains( [[and <table ]] , lu.assertEquals, {3,2,1,4,1,1,1,1,1,1,1}, {1,2,3,4,1,1,1,1,1,1,1} ) - - end - ------------------------------------------------------------------- --- --- Execution Tests --- ------------------------------------------------------------------- - -local executedTests - -MyTestToto1 = {} --class - function MyTestToto1:test1() table.insert( executedTests, "MyTestToto1:test1" ) end - function MyTestToto1:testb() table.insert( executedTests, "MyTestToto1:testb" ) end - function MyTestToto1:test3() table.insert( executedTests, "MyTestToto1:test3" ) end - function MyTestToto1:testa() table.insert( executedTests, "MyTestToto1:testa" ) end - function MyTestToto1:test2() table.insert( executedTests, "MyTestToto1:test2" ) end - -MyTestToto2 = {} --class - function MyTestToto2:test1() table.insert( executedTests, "MyTestToto2:test1" ) end - -MyTestWithErrorsAndFailures = {} --class - function MyTestWithErrorsAndFailures:testWithFailure1() lu.assertEquals(1, 2) end - function MyTestWithErrorsAndFailures:testWithFailure2() lu.assertError( function() end ) end - function MyTestWithErrorsAndFailures:testWithError1() error('some error') end - function MyTestWithErrorsAndFailures:testOk() end - -MyTestOk = {} --class - function MyTestOk:testOk1() end - function MyTestOk:testOk2() end - -function MyTestFunction() - table.insert( executedTests, "MyTestFunction" ) -end - -TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } - - function TestLuaUnitExecution:tearDown() - executedTests = {} - lu.LuaUnit.isTestName = lu.LuaUnit.isTestNameOld - end - - function TestLuaUnitExecution:setUp() - executedTests = {} - lu.LuaUnit.isTestNameOld = lu.LuaUnit.isTestName - lu.LuaUnit.isTestName = function( s ) return (string.sub(s,1,6) == 'MyTest') end - end - - function TestLuaUnitExecution:oneInstanceExists() - lu.assertEquals( #lu.LuaUnit.instances, 1 ) - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuite( 'MyTestToto2', 'MyTestToto1', 'MyTestFunction' ) - - -- number of instances cleanup was done properly - lu.assertEquals( #lu.LuaUnit.instances, 1 ) - end - - function TestLuaUnitExecution:canNotExitDuringLuaUnitExecution() - lu.assertFailure(os.exit, 0) - end - - function TestLuaUnitExecution:test_collectTests() - local allTests = lu.LuaUnit.collectTests() - lu.assertEquals( allTests, {"MyTestFunction", "MyTestOk", "MyTestToto1", "MyTestToto2","MyTestWithErrorsAndFailures"}) - end - - function TestLuaUnitExecution:test_MethodsAreExecutedInRightOrder() - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuite( 'MyTestToto1' ) - lu.assertEquals( #executedTests, 5 ) - lu.assertEquals( executedTests[1], "MyTestToto1:test1" ) - lu.assertEquals( executedTests[2], "MyTestToto1:test2" ) - lu.assertEquals( executedTests[3], "MyTestToto1:test3" ) - lu.assertEquals( executedTests[4], "MyTestToto1:testa" ) - lu.assertEquals( executedTests[5], "MyTestToto1:testb" ) - end - - function TestLuaUnitExecution:test_runSuite() - -- note: this also test that names are executed in explicit order - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuite( 'MyTestToto2', 'MyTestToto1', 'MyTestFunction' ) - lu.assertEquals( #executedTests, 7 ) - lu.assertEquals( executedTests[1], "MyTestToto2:test1" ) - lu.assertEquals( executedTests[2], "MyTestToto1:test1" ) - lu.assertEquals( executedTests[7], "MyTestFunction" ) - end - - function TestLuaUnitExecution:testRunSomeTestByGlobalInstance( ) - lu.assertEquals( #executedTests, 0 ) - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'Toto', MyTestToto1 } }, 'fake_run_unit_tests.lua' ) - lu.assertEquals( #executedTests, 5 ) - - lu.assertEquals( #runner.result.allTests, 5 ) - lu.assertEquals( runner.result.allTests[1].testName, "Toto.test1" ) - lu.assertEquals( runner.result.allTests[5].testName, "Toto.testb" ) - end - - function TestLuaUnitExecution:testRunSomeTestByLocalInstance( ) - local MyLocalTestToto1 = {} --class - function MyLocalTestToto1:test1() table.insert( executedTests, "MyLocalTestToto1:test1" ) end - local MyLocalTestToto2 = {} --class - function MyLocalTestToto2:test1() table.insert( executedTests, "MyLocalTestToto2:test1" ) end - function MyLocalTestToto2:test2() table.insert( executedTests, "MyLocalTestToto2:test2" ) end - local function MyLocalTestFunction() table.insert( executedTests, "MyLocalTestFunction" ) end - - lu.assertEquals( #executedTests, 0 ) - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { - { 'MyLocalTestToto1', MyLocalTestToto1 }, - { 'MyLocalTestToto2.test2', MyLocalTestToto2 }, - { 'MyLocalTestFunction', MyLocalTestFunction }, - }, 'fake_run_unit_tests.lua' ) - lu.assertEquals( #executedTests, 3 ) - lu.assertEquals( executedTests[1], 'MyLocalTestToto1:test1') - lu.assertEquals( executedTests[2], 'MyLocalTestToto2:test2') - lu.assertEquals( executedTests[3], 'MyLocalTestFunction') - end - - function TestLuaUnitExecution:testRunReturnsNumberOfFailures() - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - local ret = runner:runSuite( 'MyTestWithErrorsAndFailures' ) - lu.assertEquals(ret, 3) - - ret = runner:runSuite( 'MyTestToto1' ) - lu.assertEquals(ret, 0) - end - - function TestLuaUnitExecution:testTestCountAndFailCount() - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuite( 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( runner.result.selectedCount, 4) - lu.assertEquals( runner.result.notSuccessCount, 3) - lu.assertEquals( runner.result.failureCount, 2) - lu.assertEquals( runner.result.errorCount, 1) - - runner:runSuite( 'MyTestToto1' ) - lu.assertEquals( runner.result.selectedCount, 5) - lu.assertEquals( runner.result.notSuccessCount, 0) - lu.assertEquals( runner.result.failureCount, 0) - lu.assertEquals( runner.result.errorCount, 0) - end - - function TestLuaUnitExecution:testRunSetupAndTeardown() - local myExecutedTests = {} - local MyTestWithSetupTeardown = {} - function MyTestWithSetupTeardown:setUp() table.insert( myExecutedTests, '1setUp' ) end - function MyTestWithSetupTeardown:test1() table.insert( myExecutedTests, '1test1' ) end - function MyTestWithSetupTeardown:test2() table.insert( myExecutedTests, '1test2' ) end - function MyTestWithSetupTeardown:tearDown() table.insert( myExecutedTests, '1tearDown' ) end - - local MyTestWithSetupTeardown2 = {} - function MyTestWithSetupTeardown2:setUp() table.insert( myExecutedTests, '2setUp' ) end - function MyTestWithSetupTeardown2:test1() table.insert( myExecutedTests, '2test1' ) end - function MyTestWithSetupTeardown2:tearDown() table.insert( myExecutedTests, '2tearDown' ) end - - local MyTestWithSetupTeardown3 = {} - function MyTestWithSetupTeardown3:Setup() table.insert( myExecutedTests, '3Setup' ) end - function MyTestWithSetupTeardown3:test1() table.insert( myExecutedTests, '3test1' ) end - function MyTestWithSetupTeardown3:Teardown() table.insert( myExecutedTests, '3Teardown' ) end - - local MyTestWithSetupTeardown4 = {} - function MyTestWithSetupTeardown4:setup() table.insert( myExecutedTests, '4setup' ) end - function MyTestWithSetupTeardown4:test1() table.insert( myExecutedTests, '4test1' ) end - function MyTestWithSetupTeardown4:teardown() table.insert( myExecutedTests, '4teardown' ) end - - local MyTestWithSetupTeardown5 = {} - function MyTestWithSetupTeardown5:SetUp() table.insert( myExecutedTests, '5SetUp' ) end - function MyTestWithSetupTeardown5:test1() table.insert( myExecutedTests, '5test1' ) end - function MyTestWithSetupTeardown5:TearDown() table.insert( myExecutedTests, '5TearDown' ) end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupTeardown.test1', MyTestWithSetupTeardown } } ) - lu.assertEquals( runner.result.notSuccessCount, 0 ) - lu.assertEquals( myExecutedTests[1], '1setUp' ) - lu.assertEquals( myExecutedTests[2], '1test1') - lu.assertEquals( myExecutedTests[3], '1tearDown') - lu.assertEquals( #myExecutedTests, 3) - - myExecutedTests = {} - runner:runSuiteByInstances( { - { 'MyTestWithSetupTeardown', MyTestWithSetupTeardown }, - { 'MyTestWithSetupTeardown2', MyTestWithSetupTeardown2 }, - { 'MyTestWithSetupTeardown3', MyTestWithSetupTeardown3 }, - { 'MyTestWithSetupTeardown4', MyTestWithSetupTeardown4 }, - { 'MyTestWithSetupTeardown5', MyTestWithSetupTeardown5 } - }, 'fake_run_unit_tests.lua' ) - lu.assertEquals( runner.result.notSuccessCount, 0 ) - lu.assertEquals( myExecutedTests[1], '1setUp' ) - lu.assertEquals( myExecutedTests[2], '1test1') - lu.assertEquals( myExecutedTests[3], '1tearDown') - lu.assertEquals( myExecutedTests[4], '1setUp' ) - lu.assertEquals( myExecutedTests[5], '1test2') - lu.assertEquals( myExecutedTests[6], '1tearDown') - lu.assertEquals( myExecutedTests[7], '2setUp' ) - lu.assertEquals( myExecutedTests[8], '2test1') - lu.assertEquals( myExecutedTests[9], '2tearDown') - lu.assertEquals( myExecutedTests[10], '3Setup') - lu.assertEquals( myExecutedTests[11], '3test1') - lu.assertEquals( myExecutedTests[12], '3Teardown') - lu.assertEquals( myExecutedTests[13], '4setup') - lu.assertEquals( myExecutedTests[14], '4test1') - lu.assertEquals( myExecutedTests[15], '4teardown') - lu.assertEquals( myExecutedTests[16], '5SetUp') - lu.assertEquals( myExecutedTests[17], '5test1') - lu.assertEquals( myExecutedTests[18], '5TearDown') - lu.assertEquals( #myExecutedTests, 18) - end - - function TestLuaUnitExecution:testWithSetupTeardownFailure1() - local myExecutedTests = {} - - local MyTestWithSetupFailure = {} - function MyTestWithSetupFailure:setUp() table.insert( myExecutedTests, 'setUp' ) lu.assertEquals( 'b', 'c') end - function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) end - function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'tearDown') - lu.assertEquals( #myExecutedTests, 2) - lu.assertEquals( runner.result.failedTests[1].status, lu.NodeStatus.FAIL ) - end - - function TestLuaUnitExecution:testWithSetupTeardownFailure2() - local myExecutedTests = {} - - local MyTestWithSetupFailure = {} - function MyTestWithSetupFailure:setUp() table.insert( myExecutedTests, 'setUp' ) end - function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) end - function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'b', 'c') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'test1' ) - lu.assertEquals( myExecutedTests[3], 'tearDown') - lu.assertEquals( #myExecutedTests, 3) - lu.assertEquals( runner.result.failedTests[1].status, lu.NodeStatus.FAIL ) - end - - function TestLuaUnitExecution:testWithSetupTeardownFailure3() - local myExecutedTests = {} - - local MyTestWithSetupFailure = {} - function MyTestWithSetupFailure:setUp() table.insert( myExecutedTests, 'setUp' ) lu.assertEquals( 'b', 'c') end - function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) end - function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'b', 'c') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report two failures for this - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'tearDown') - lu.assertEquals( #myExecutedTests, 2) - lu.assertEquals( runner.result.failedTests[1].status, lu.NodeStatus.FAIL ) - end - - function TestLuaUnitExecution:testWithSetupTeardownFailure4() - local myExecutedTests = {} - - local MyTestWithSetupFailure = {} - function MyTestWithSetupFailure:setUp() table.insert( myExecutedTests, 'setUp' ) lu.assertEquals( 'b', 'c') end - function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) lu.assertEquals( 'b', 'c') end - function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'b', 'c') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report two failures for this - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'tearDown') - lu.assertEquals( #myExecutedTests, 2) - lu.assertEquals( runner.result.failedTests[1].status, lu.NodeStatus.FAIL ) - end - - function TestLuaUnitExecution:testWithSetupTeardownFailure5() - local myExecutedTests = {} - - local MyTestWithSetupFailure = {} - function MyTestWithSetupFailure:setUp() table.insert( myExecutedTests, 'setUp' ) end - function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) lu.assertEquals( 'b', 'c') end - function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'b', 'c') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report two failures for this - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'test1' ) - lu.assertEquals( myExecutedTests[3], 'tearDown') - lu.assertEquals( #myExecutedTests, 3) - lu.assertEquals( runner.result.failedTests[1].status, lu.NodeStatus.FAIL ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrors1() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) error('setup error') end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'tearDown') - lu.assertEquals( #myExecutedTests, 2) - lu.assertEquals( runner.result.errorTests[1].status, lu.NodeStatus.ERROR ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrors2() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'test1' ) - lu.assertEquals( myExecutedTests[3], 'tearDown') - lu.assertEquals( #myExecutedTests, 3) - lu.assertEquals( runner.result.errorTests[1].status, lu.NodeStatus.ERROR ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrors3() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) error('setup error') end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report two errors for this - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'tearDown') - lu.assertEquals( #myExecutedTests, 2) - lu.assertEquals( runner.result.errorTests[1].status, lu.NodeStatus.ERROR ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrors4() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) error('setup error') end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) error('test error') end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report two errors for this - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'tearDown') - lu.assertEquals( #myExecutedTests, 2) - lu.assertEquals( runner.result.errorTests[1].status, lu.NodeStatus.ERROR ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrors5() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) error('test error') end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report two errors for this - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'test1' ) - lu.assertEquals( myExecutedTests[3], 'tearDown') - lu.assertEquals( #myExecutedTests, 3) - lu.assertEquals( runner.result.errorTests[1].status, lu.NodeStatus.ERROR ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrorsAndFailures1() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) lu.assertEquals( 'a', 'b') end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report failure + error for this - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'tearDown') - lu.assertEquals( #myExecutedTests, 2) - -- The first error/failure set the whole test status - lu.assertEquals( runner.result.failedTests[1].status, lu.NodeStatus.FAIL ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrorsAndFailures2() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) error('setup error') end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'a', 'b') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report failure + error for this - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'tearDown') - lu.assertEquals( #myExecutedTests, 2) - -- The first error/failure set the whole test status - lu.assertEquals( runner.result.errorTests[1].status, lu.NodeStatus.ERROR ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrorsAndFailures3() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) error('test error') end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'a', 'b') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report failure + error for this - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'test1' ) - lu.assertEquals( myExecutedTests[3], 'tearDown') - lu.assertEquals( #myExecutedTests, 3) - -- The first error/failure set the whole test status - lu.assertEquals( runner.result.errorTests[1].status, lu.NodeStatus.ERROR ) - end - - function TestLuaUnitExecution:testWithSetupTeardownErrorsAndFailures4() - local myExecutedTests = {} - - local MyTestWithSetupError = {} - function MyTestWithSetupError:setUp() table.insert( myExecutedTests, 'setUp' ) end - function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) lu.assertEquals( 'a', 'b') end - function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) - lu.assertEquals( runner.result.notSuccessCount, 1 ) - -- Note: in the future, we may want to report failure + error for this - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( myExecutedTests[1], 'setUp' ) - lu.assertEquals( myExecutedTests[2], 'test1' ) - lu.assertEquals( myExecutedTests[3], 'tearDown') - lu.assertEquals( #myExecutedTests, 3) - -- The first error/failure set the whole test status - lu.assertEquals( runner.result.failedTests[1].status, lu.NodeStatus.FAIL ) - end - - function TestLuaUnitExecution:testWithSetupSuite_TeardownSuite() - local myExecutedTests = {} - - local setupSuite = function() table.insert( myExecutedTests, 'setupSuite' ) end - local teardownSuite = function() table.insert( myExecutedTests, 'teardownSuite') end - - local MyTestClassA = { - test1 = function() table.insert( myExecutedTests, 'Atest1' ) end - } - - local MyTestClassB = { - test1 = function() table.insert( myExecutedTests, 'Btest1' ) end - } - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner.patternIncludeFilter = {"test"} - - - runner:internalRunSuiteByInstances( { - { 'setupSuite', setupSuite }, - { 'teardownSuite', teardownSuite }, - { 'MyTestClassA', MyTestClassA }, - { 'MyTestClassB', MyTestClassB } - } ) - lu.assertEquals( runner.result.notSuccessCount, 0 ) - lu.assertEquals( myExecutedTests[1], 'setupSuite' ) - lu.assertEquals( myExecutedTests[2], 'Atest1') - lu.assertEquals( myExecutedTests[3], 'Btest1') - lu.assertEquals( myExecutedTests[4], 'teardownSuite') - lu.assertEquals( #myExecutedTests, 4) - end - - function TestLuaUnitExecution:testWithSetupClass_TeardownClass() - local myExecutedTests = {} - - local MyTestClassA = { - setupClass = function() table.insert( myExecutedTests, 'AsetupClass' ) end, - teardownClass = function() table.insert( myExecutedTests, 'AteardownClass' ) end, - test1 = function() table.insert( myExecutedTests, 'Atest1' ) end, - test2 = function() table.insert( myExecutedTests, 'Atest2' ) end - } - - local MyTestClassB = { - setupClass = function() table.insert( myExecutedTests, 'BsetupClass' ) end, - teardownClass = function() table.insert( myExecutedTests, 'BteardownClass' ) end, - test1 = function() table.insert( myExecutedTests, 'Btest1' ) end, - test2 = function() table.insert( myExecutedTests, 'Btest2' ) end - } - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner.patternIncludeFilter = {"test"} - - runner:runSuiteByInstances( { - { 'MyTestClassA', MyTestClassA }, - { 'MyTestClassB', MyTestClassB } - }, 'fake_run_unit_tests.lua' ) - lu.assertEquals( runner.result.notSuccessCount, 0 ) - lu.assertEquals( myExecutedTests[1], 'AsetupClass' ) - lu.assertEquals( myExecutedTests[2], 'Atest1') - lu.assertEquals( myExecutedTests[3], 'Atest2') - lu.assertEquals( myExecutedTests[4], 'AteardownClass') - - lu.assertEquals( myExecutedTests[5], 'BsetupClass' ) - lu.assertEquals( myExecutedTests[6], 'Btest1') - lu.assertEquals( myExecutedTests[7], 'Btest2') - lu.assertEquals( myExecutedTests[8], 'BteardownClass') - - lu.assertEquals( #myExecutedTests, 8) - end - - function TestLuaUnitExecution:testWithSetupAndTeardownForSuiteAndClassAndTests() - local myExecutedTests = {} - - local setupSuite = function() table.insert( myExecutedTests, 'setupSuite' ) end - local teardownSuite = function() table.insert( myExecutedTests, 'teardownSuite') end - - local MyTestClassA = { - setupClass = function() table.insert( myExecutedTests, 'AsetupClass' ) end, - teardownClass = function() table.insert( myExecutedTests, 'AteardownClass' ) end, - test1 = function() table.insert( myExecutedTests, 'Atest1' ) end, - test2 = function() table.insert( myExecutedTests, 'Atest2' ) end - } - - local MyTestClassB = { - test1 = function() table.insert( myExecutedTests, 'Btest1' ) end, - test2 = function() table.insert( myExecutedTests, 'Btest2' ) end, - setup = function() table.insert( myExecutedTests, 'Bsetup' ) end - } - - local MyTestClassC = { - test1 = function() table.insert( myExecutedTests, 'Ctest1' ) end, - test2 = function() table.insert( myExecutedTests, 'Ctest2' ) end, - teardown = function() table.insert( myExecutedTests, 'Cteardown' ) end - } - - local MyTestClassD = { - test1 = function() table.insert( myExecutedTests, 'Dtest1' ) end, - test2 = function() table.insert( myExecutedTests, 'Dtest2' ) end, - teardown = function() table.insert( myExecutedTests, 'Dteardown' ) end, - setup = function() table.insert( myExecutedTests, 'Dsetup' ) end, - setupClass = function() table.insert( myExecutedTests, 'DsetupClass' ) end, - teardownClass = function() table.insert( myExecutedTests, 'DteardownClass' ) end - } - - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner.patternIncludeFilter = {"test"} - - runner:internalRunSuiteByInstances( { - { 'MyTestClassA', MyTestClassA }, - { 'MyTestClassB', MyTestClassB }, - { 'MyTestClassC', MyTestClassC }, - { 'MyTestClassD', MyTestClassD }, - { 'setupSuite', setupSuite }, - { 'teardownSuite', teardownSuite } - } ) - lu.assertEquals( runner.result.notSuccessCount, 0 ) - lu.assertEquals( myExecutedTests[1], 'setupSuite' ) - - lu.assertEquals( myExecutedTests[2], 'AsetupClass') - lu.assertEquals( myExecutedTests[3], 'Atest1') - lu.assertEquals( myExecutedTests[4], 'Atest2') - lu.assertEquals( myExecutedTests[5], 'AteardownClass') - - lu.assertEquals( myExecutedTests[6], 'Bsetup') - lu.assertEquals( myExecutedTests[7], 'Btest1') - lu.assertEquals( myExecutedTests[8], 'Bsetup') - lu.assertEquals( myExecutedTests[9], 'Btest2') - - lu.assertEquals( myExecutedTests[10], 'Ctest1') - lu.assertEquals( myExecutedTests[11], 'Cteardown') - lu.assertEquals( myExecutedTests[12], 'Ctest2') - lu.assertEquals( myExecutedTests[13], 'Cteardown') - - lu.assertEquals( myExecutedTests[14], 'DsetupClass') - lu.assertEquals( myExecutedTests[15], 'Dsetup') - lu.assertEquals( myExecutedTests[16], 'Dtest1') - lu.assertEquals( myExecutedTests[17], 'Dteardown') - lu.assertEquals( myExecutedTests[18], 'Dsetup') - lu.assertEquals( myExecutedTests[19], 'Dtest2') - lu.assertEquals( myExecutedTests[20], 'Dteardown') - lu.assertEquals( myExecutedTests[21], 'DteardownClass') - lu.assertEquals( myExecutedTests[22], 'teardownSuite') - - - lu.assertEquals( #myExecutedTests, 22) - end - - function TestLuaUnitExecution:test_failFromTest() - - local function my_test_fails() - lu.assertEquals( 1, 1 ) - lu.fail( 'Stop early.') - end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'my_test_fails', my_test_fails } } ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertStrContains( runner.result.failedTests[1].msg, 'Stop early.' ) - end - - function TestLuaUnitExecution:test_failIfFromTest() - - local function my_test_fails() - lu.assertEquals( 1, 1 ) - lu.failIf( false, 'NOOOOOOOOOO') - lu.failIf( nil, 'NOOOOOOOOOO') - lu.failIf( 1 == 1, 'YESSS') - end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'my_test_fails', my_test_fails } } ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertStrContains( runner.result.failedTests[1].msg, 'YESS' ) - end - - function TestLuaUnitExecution:test_callSuccessFromTest() - - local function my_test_success() - lu.assertEquals( 1, 1 ) - lu.success() - error('toto') - end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'my_test_success', my_test_success } } ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.successCount, 1 ) - end - - function TestLuaUnitExecution:test_callSuccessIfFromTest() - - local function my_test_fails() - lu.assertEquals( 1, 1 ) - lu.successIf( false ) - error('titi') - end - - local function my_test_success() - lu.assertEquals( 1, 1 ) - lu.successIf( true ) - error('toto') - end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'my_test_fails', my_test_fails }, {'my_test_success', my_test_success} } ) - lu.assertEquals( runner.result.selectedCount, 2 ) - -- print( lu.prettystr( runner.result ) ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.successCount, 1 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertStrContains( runner.result.errorTests[1].msg, 'titi' ) - end - - function TestLuaUnitExecution:test_callSkipFromTest() - - local function my_test_skip() - lu.skip('my_skip_msg_is_there') - error('skip does not work!') - end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'my_test_skip', my_test_skip } } ) - lu.assertEquals( runner.result.selectedCount, 1 ) - lu.assertEquals( runner.result.runCount, 0 ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 0 ) - lu.assertEquals( runner.result.successCount, 0 ) - lu.assertEquals( runner.result.skippedCount, 1 ) - lu.assertStrContains( runner.result.skippedTests[1].msg, 'my_skip_msg_is_there' ) - end - - function TestLuaUnitExecution:test_callSkipIfFromTest() - - local function my_test_skip() - lu.skipIf( false, 'test is not skipped' ) - error('titi') - end - - local function my_test_no_skip() - lu.skipIf( true, 'test should be skipped' ) - error('toto') - end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'my_test_skip', my_test_skip }, {'my_test_no_skip', my_test_no_skip} } ) - lu.assertEquals( runner.result.selectedCount, 2 ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.successCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.skippedCount, 1 ) - lu.assertEquals( runner.result.runCount, 1 ) - lu.assertStrContains( runner.result.errorTests[1].msg, 'titi' ) - lu.assertStrContains( runner.result.skippedTests[1].msg, 'test should be skipped' ) - end - - - function TestLuaUnitExecution:test_callRunOnlyIfFromTest() - - local function my_test_run_only_if() - lu.runOnlyIf( true, 'test is executed' ) - error('titi') - end - - local function my_test_not_run_only_if() - lu.runOnlyIf( false, 'test should be skipped' ) - error('toto') - end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { { 'my_test_run_only_if', my_test_run_only_if }, {'my_test_not_run_only_if', my_test_not_run_only_if} } ) - lu.assertEquals( runner.result.selectedCount, 2 ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.successCount, 0 ) - lu.assertEquals( runner.result.skippedCount, 1 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.result.runCount, 1 ) - lu.assertStrContains( runner.result.errorTests[1].msg, 'titi' ) - lu.assertStrContains( runner.result.skippedTests[1].msg, 'test should be skipped' ) - end - - - function TestLuaUnitExecution:testWithRepeat() - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - local nbIter = 0 - - -- for runSuite() we need a function in the global scope - local function MyTestWithIteration() - nbIter = nbIter + 1 - lu.assertTrue( nbIter <= 5 ) - end - - _G.MyTestWithIteration = MyTestWithIteration - nbIter = 0 - runner:runSuite( '--repeat', '5', - 'MyTestWithIteration') - _G.MyTestWithIteration = nil -- clean up - lu.assertEquals( runner.result.successCount, 1 ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.exeRepeat, 5 ) - lu.assertEquals( runner.currentCount, 5 ) - lu.assertEquals( nbIter, 5 ) - - _G.MyTestWithIteration = MyTestWithIteration - nbIter = 0 - runner:runSuite( '--repeat', '10', - 'MyTestWithIteration') - _G.MyTestWithIteration = nil -- clean up - -- check if the current iteration got reflected in the failure message - lu.assertEquals( runner.result.successCount, 0 ) - lu.assertEquals( runner.result.failureCount, 1 ) - lu.assertEquals( runner.exeRepeat, 10 ) - lu.assertEquals( runner.currentCount, 6 ) - -- print( lu.prettystr( runner.result ) ) - lu.assertStrContains(runner.result.failedTests[1].msg, "iteration 6") - lu.assertStrContains(runner.result.failedTests[1].msg, "expected: true, ") - - local function MyTestWithIteration() - nbIter = nbIter + 1 - if nbIter > 5 then - error( 'Exceeding 5') - end - end - - _G.MyTestWithIteration = MyTestWithIteration - nbIter = 0 - runner:runSuite( '--repeat', '10', - 'MyTestWithIteration') - _G.MyTestWithIteration = nil -- clean up - -- check if the current iteration got reflected in the failure message - lu.assertEquals( runner.result.successCount, 0 ) - lu.assertEquals( runner.result.failureCount, 0 ) - lu.assertEquals( runner.result.errorCount, 1 ) - lu.assertEquals( runner.exeRepeat, 10 ) - lu.assertEquals( runner.currentCount, 6 ) - -- print( lu.prettystr( runner.result ) ) - lu.assertStrContains(runner.result.errorTests[1].msg, "iteration 6") - lu.assertStrContains(runner.result.errorTests[1].msg, "Exceeding 5" ) - end - - - function TestLuaUnitExecution:testOutputInterface() - local runner = lu.LuaUnit.new() - runner.outputType = Mock - runner:runSuite( 'MyTestWithErrorsAndFailures', 'MyTestOk' ) - local m = runner.output - - lu.assertEquals( m.calls[1][1], 'startSuite' ) - lu.assertEquals(#m.calls[1], 2 ) - - lu.assertEquals( m.calls[2][1], 'startClass' ) - lu.assertEquals( m.calls[2][3], 'MyTestWithErrorsAndFailures' ) - lu.assertEquals(#m.calls[2], 3 ) - - lu.assertEquals( m.calls[3][1], 'startTest' ) - lu.assertEquals( m.calls[3][3], 'MyTestWithErrorsAndFailures.testOk' ) - lu.assertEquals(#m.calls[3], 3 ) - - lu.assertEquals( m.calls[4][1], 'endTest' ) - lu.assertEquals(#m.calls[4], 3 ) - lu.assertIsTable( m.calls[4][3] ) - lu.assertEquals( m.calls[4][3].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( m.calls[5][1], 'startTest' ) - lu.assertEquals( m.calls[5][3], 'MyTestWithErrorsAndFailures.testWithError1' ) - lu.assertEquals(#m.calls[5], 3 ) - - lu.assertEquals( m.calls[6][1], 'updateStatus' ) - lu.assertEquals(#m.calls[6], 3 ) - - lu.assertEquals( m.calls[7][1], 'endTest' ) - lu.assertEquals(#m.calls[7], 3 ) - lu.assertIsTable( m.calls[7][3] ) - lu.assertEquals( m.calls[7][3].status, lu.NodeStatus.ERROR ) - - - lu.assertEquals( m.calls[8][1], 'startTest' ) - lu.assertEquals( m.calls[8][3], 'MyTestWithErrorsAndFailures.testWithFailure1' ) - lu.assertEquals(#m.calls[8], 3 ) - - lu.assertEquals( m.calls[9][1], 'updateStatus' ) - lu.assertEquals(#m.calls[9], 3 ) - - lu.assertEquals( m.calls[10][1], 'endTest' ) - lu.assertEquals(#m.calls[10], 3 ) - lu.assertIsTable( m.calls[10][3] ) - lu.assertEquals( m.calls[10][3].status, lu.NodeStatus.FAIL ) - - lu.assertEquals( m.calls[11][1], 'startTest' ) - lu.assertEquals( m.calls[11][3], 'MyTestWithErrorsAndFailures.testWithFailure2' ) - lu.assertEquals(#m.calls[11], 3 ) - - lu.assertEquals( m.calls[12][1], 'updateStatus' ) - lu.assertEquals(#m.calls[12], 3 ) - - lu.assertEquals( m.calls[13][1], 'endTest' ) - lu.assertEquals(#m.calls[13], 3 ) - lu.assertIsTable(m.calls[13][3] ) - lu.assertEquals( m.calls[13][3].status, lu.NodeStatus.FAIL ) - - lu.assertEquals( m.calls[14][1], 'endClass' ) - lu.assertEquals(#m.calls[14], 2 ) - - lu.assertEquals( m.calls[15][1], 'startClass' ) - lu.assertEquals( m.calls[15][3], 'MyTestOk' ) - lu.assertEquals(#m.calls[15], 3 ) - - lu.assertEquals( m.calls[16][1], 'startTest' ) - lu.assertEquals( m.calls[16][3], 'MyTestOk.testOk1' ) - lu.assertEquals(#m.calls[16], 3 ) - - lu.assertEquals( m.calls[17][1], 'endTest' ) - lu.assertEquals(#m.calls[17], 3 ) - lu.assertIsTable( m.calls[17][3] ) - lu.assertEquals( m.calls[17][3].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( m.calls[18][1], 'startTest' ) - lu.assertEquals( m.calls[18][3], 'MyTestOk.testOk2' ) - lu.assertEquals(#m.calls[18], 3 ) - - lu.assertEquals( m.calls[19][1], 'endTest' ) - lu.assertEquals(#m.calls[19], 3 ) - lu.assertIsTable( m.calls[19][3] ) - lu.assertEquals( m.calls[19][3].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( m.calls[20][1], 'endClass' ) - lu.assertEquals(#m.calls[20], 2 ) - - lu.assertEquals( m.calls[21][1], 'endSuite' ) - lu.assertEquals(#m.calls[21], 2 ) - - lu.assertEquals( m.calls[22], nil ) - - end - - function TestLuaUnitExecution:testInvocation() - - lu.assertEquals( #lu.LuaUnit.instances, 1) - local runner = lu.LuaUnit.new() - - -- this does not create a new registered instance - lu.assertEquals( #lu.LuaUnit.instances, 1) - - -- test alternative "object" syntax for run(), passing self - runner:run('--output', 'nil', 'MyTestOk') - - -- this does not create a new registered instance - lu.assertEquals( #lu.LuaUnit.instances, 1) - - -- select class instance by name - runner.run('--output', 'nil', 'MyTestOk.testOk2') - - -- this does not create a new registered instance - lu.assertEquals( #lu.LuaUnit.instances, 1) - - -- check error handling - lu.assertErrorMsgContains('No such name in global space', - runner.runSuite, runner, 'foobar') - lu.assertEquals( #lu.LuaUnit.instances, 1) - lu.assertErrorMsgContains('Name must match a function or a table', - runner.runSuite, runner, '_VERSION') - lu.assertEquals( #lu.LuaUnit.instances, 1) - lu.assertErrorMsgContains('No such name in global space', - runner.runSuite, runner, 'foo.bar') - lu.assertEquals( #lu.LuaUnit.instances, 1) - lu.assertErrorMsgContains('must be a function, not', - runner.runSuite, runner, '_G._VERSION') - lu.assertEquals( #lu.LuaUnit.instances, 1) - lu.assertErrorMsgContains('Could not find method in class', - runner.runSuite, runner, 'MyTestOk.foobar') - lu.assertEquals( #lu.LuaUnit.instances, 1) - lu.assertErrorMsgContains('Instance must be a table or a function', - runner.expandClasses, {{'foobar', 'INVALID'}}) - lu.assertEquals( #lu.LuaUnit.instances, 1) - lu.assertErrorMsgContains('Could not find method in class', - runner.expandClasses, {{'MyTestOk.foobar', {}}}) - lu.assertEquals( #lu.LuaUnit.instances, 1) - end - - function TestLuaUnitExecution:test_filterWithPattern() - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuite('-p', 'Function', '-p', 'Toto.' ) - lu.assertEquals( executedTests[1], "MyTestFunction" ) - lu.assertEquals( executedTests[2], "MyTestToto1:test1" ) - lu.assertEquals( executedTests[3], "MyTestToto1:test2" ) - lu.assertEquals( executedTests[4], "MyTestToto1:test3" ) - lu.assertEquals( executedTests[5], "MyTestToto1:testa" ) - lu.assertEquals( executedTests[6], "MyTestToto1:testb" ) - lu.assertEquals( executedTests[7], "MyTestToto2:test1" ) - lu.assertEquals( #executedTests, 7) - - runner:runSuite('-p', 'Toto.', '-x', 'Toto2' ) - lu.assertEquals( runner.result.selectedCount, 5) -- MyTestToto2 excluded - end - - function TestLuaUnitExecution:test_endSuiteTwice() - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuite( 'MyTestWithErrorsAndFailures', 'MyTestOk' ) - lu.assertErrorMsgContains('suite was already ended', - runner.endSuite, runner) - end - - function TestLuaUnitExecution:test_withTableErrorInside(args) - local function my_test_with_table_error() - error {code = 123} - end - - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuiteByInstances { { 'my_test_with_table_error', my_test_with_table_error } } - lu.assertStrContains(runner.result.allTests[1].msg, '{code=123}') - end - - - ------------------------------------------------------------------- --- --- Results Tests --- ------------------------------------------------------------------- - -TestLuaUnitResults = { __class__ = 'TestLuaUnitResults' } - - function TestLuaUnitResults:tearDown() - executedTests = {} - lu.LuaUnit.isTestName = lu.LuaUnit.isTestNameOld - end - - function TestLuaUnitResults:setUp() - executedTests = {} - lu.LuaUnit.isTestNameOld = lu.LuaUnit.isTestName - lu.LuaUnit.isTestName = function( s ) return (string.sub(s,1,6) == 'MyTest') end - end - - function TestLuaUnitResults:test_statusLine() - -- full success - local r = {runCount=5, duration=0.17, successCount=5, notSuccessCount=0, failureCount=0, errorCount=0, nonSelectedCount=0, skippedCount=0} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 5 successes, 0 failures') - - -- 1 failure, nothing more displayed - r = {runCount=5, duration=0.17, successCount=4, notSuccessCount=1, failureCount=1, errorCount=0, nonSelectedCount=0, skippedCount=0} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 4 successes, 1 failure') - - -- 1 error, no failure displayed - r = {runCount=5, duration=0.17, successCount=4, notSuccessCount=1, failureCount=0, errorCount=1, nonSelectedCount=0, skippedCount=0} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 4 successes, 1 error') - - -- 1 error, 1 failure - r = {runCount=5, duration=0.17, successCount=3, notSuccessCount=2, failureCount=1, errorCount=1, nonSelectedCount=0, skippedCount=0} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 3 successes, 1 failure, 1 error') - - -- 1 error, 1 failure, 1 non selected - r = {runCount=5, duration=0.17, successCount=3, notSuccessCount=2, failureCount=1, errorCount=1, nonSelectedCount=1, skippedCount=0} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 3 successes, 1 failure, 1 error, 1 non-selected') - - -- full success, 1 non selected - r = {runCount=5, duration=0.17, successCount=5, notSuccessCount=0, failureCount=0, errorCount=0, nonSelectedCount=1, skippedCount=0} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 5 successes, 0 failures, 1 non-selected') - - -- 1 error, 1 failure, 1 skipped - r = {runCount=5, duration=0.17, successCount=3, notSuccessCount=2, failureCount=1, errorCount=1, nonSelectedCount=0, skippedCount=1} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 3 successes, 1 failure, 1 error, 1 skipped') - - -- full success, 1 skipped - r = {runCount=5, duration=0.17, successCount=5, notSuccessCount=0, failureCount=0, errorCount=0, nonSelectedCount=0, skippedCount=1} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 5 successes, 0 failures, 1 skipped') - - -- full success, 1 skipped, 1 non-selected - r = {runCount=5, duration=0.17, successCount=5, notSuccessCount=0, failureCount=0, errorCount=0, nonSelectedCount=1, skippedCount=1} - lu.assertEquals( lu.LuaUnit.statusLine(r), 'Ran 5 tests in 0.170 seconds, 5 successes, 0 failures, 1 skipped, 1 non-selected') - - end - - function TestLuaUnitResults:test_nodeStatus() - local es = lu.NodeStatus.new() - lu.assertEquals( es.status, lu.NodeStatus.SUCCESS ) - lu.assertTrue( es:isSuccess() ) - lu.assertNil( es.msg ) - lu.assertNil( es.stackTrace ) - lu.assertStrContains( es:statusXML(), "<passed" ) - - es:fail( 'msgToto', 'stackTraceToto' ) - lu.assertEquals( es.status, lu.NodeStatus.FAIL ) - lu.assertTrue( es:isNotSuccess() ) - lu.assertTrue( es:isFailure() ) - lu.assertFalse( es:isError() ) - lu.assertEquals( es.msg, 'msgToto' ) - lu.assertEquals( es.stackTrace, 'stackTraceToto' ) - lu.assertStrContains( es:statusXML(), "<failure" ) - - local es2 = lu.NodeStatus.new() - lu.assertEquals( es2.status, lu.NodeStatus.SUCCESS ) - lu.assertNil( es2.msg ) - lu.assertNil( es2.stackTrace ) - - es:error( 'msgToto2', 'stackTraceToto2' ) - lu.assertEquals( es.status, lu.NodeStatus.ERROR ) - lu.assertTrue( es:isNotSuccess() ) - lu.assertFalse( es:isFailure() ) - lu.assertTrue( es:isError() ) - lu.assertEquals( es.msg, 'msgToto2' ) - lu.assertEquals( es.stackTrace, 'stackTraceToto2' ) - lu.assertStrContains( es:statusXML(), "<error" ) - - es:success() - lu.assertEquals( es.status, lu.NodeStatus.SUCCESS ) - lu.assertTrue( es:isSuccess() ) - lu.assertFalse( es:isNotSuccess() ) - lu.assertFalse( es:isFailure() ) - lu.assertFalse( es:isError() ) - lu.assertNil( es.msg ) - lu.assertNil( es.stackTrace ) - - end - - function TestLuaUnitResults:test_runSuiteOk() - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuite( 'MyTestToto2', 'MyTestToto1', 'MyTestFunction' ) - lu.assertEquals( #runner.result.allTests, 7 ) - lu.assertEquals( #runner.result.failedTests, 0 ) - lu.assertEquals( #runner.result.errorTests, 0 ) - - lu.assertEquals( runner.result.allTests[1].testName,"MyTestToto2.test1" ) - lu.assertEquals( runner.result.allTests[1].number, 1 ) - lu.assertEquals( runner.result.allTests[1].className, 'MyTestToto2' ) - lu.assertEquals( runner.result.allTests[1].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( runner.result.allTests[2].testName,"MyTestToto1.test1" ) - lu.assertEquals( runner.result.allTests[2].number, 2 ) - lu.assertEquals( runner.result.allTests[2].className, 'MyTestToto1' ) - lu.assertEquals( runner.result.allTests[2].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( runner.result.allTests[3].testName,"MyTestToto1.test2" ) - lu.assertEquals( runner.result.allTests[3].number, 3 ) - lu.assertEquals( runner.result.allTests[3].className, 'MyTestToto1' ) - lu.assertEquals( runner.result.allTests[3].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( runner.result.allTests[4].testName,"MyTestToto1.test3" ) - lu.assertEquals( runner.result.allTests[4].number, 4 ) - lu.assertEquals( runner.result.allTests[4].className, 'MyTestToto1' ) - lu.assertEquals( runner.result.allTests[4].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( runner.result.allTests[5].testName,"MyTestToto1.testa" ) - lu.assertEquals( runner.result.allTests[5].number, 5 ) - lu.assertEquals( runner.result.allTests[5].className, 'MyTestToto1' ) - lu.assertEquals( runner.result.allTests[5].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( runner.result.allTests[6].testName,"MyTestToto1.testb" ) - lu.assertEquals( runner.result.allTests[6].number, 6 ) - lu.assertEquals( runner.result.allTests[6].className, 'MyTestToto1' ) - lu.assertEquals( runner.result.allTests[6].status, lu.NodeStatus.SUCCESS ) - - lu.assertEquals( runner.result.allTests[7].testName,"MyTestFunction" ) - lu.assertEquals( runner.result.allTests[7].number, 7) - lu.assertEquals( runner.result.allTests[7].className, '[TestFunctions]' ) - lu.assertEquals( runner.result.allTests[7].status, lu.NodeStatus.SUCCESS ) - - end - - function TestLuaUnitResults:test_runSuiteWithFailures() - local runner = lu.LuaUnit.new() - runner:setOutputType( "NIL" ) - runner:runSuite( 'MyTestWithErrorsAndFailures' ) - - lu.assertEquals( #runner.result.allTests, 4 ) - lu.assertEquals( #runner.result.failedTests, 2 ) - lu.assertEquals( #runner.result.errorTests, 1 ) - - lu.assertEquals( runner.result.allTests[1].number, 1 ) - lu.assertEquals( runner.result.allTests[1].testName, "MyTestWithErrorsAndFailures.testOk" ) - lu.assertEquals( runner.result.allTests[1].className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( runner.result.allTests[1].status, lu.NodeStatus.SUCCESS ) - lu.assertIsNumber( runner.result.allTests[1].duration ) - lu.assertIsNil( runner.result.allTests[1].msg ) - lu.assertIsNil( runner.result.allTests[1].stackTrace ) - - lu.assertEquals( runner.result.allTests[2].testName, 'MyTestWithErrorsAndFailures.testWithError1' ) - lu.assertEquals( runner.result.allTests[2].className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( runner.result.allTests[2].status, lu.NodeStatus.ERROR ) - lu.assertIsString( runner.result.allTests[2].msg ) - lu.assertIsString( runner.result.allTests[2].stackTrace ) - - lu.assertEquals( runner.result.allTests[3].testName, 'MyTestWithErrorsAndFailures.testWithFailure1' ) - lu.assertEquals( runner.result.allTests[3].className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( runner.result.allTests[3].status, lu.NodeStatus.FAIL ) - lu.assertIsString( runner.result.allTests[3].msg ) - lu.assertIsString( runner.result.allTests[3].stackTrace ) - - lu.assertEquals( runner.result.allTests[4].testName, 'MyTestWithErrorsAndFailures.testWithFailure2' ) - lu.assertEquals( runner.result.allTests[4].className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( runner.result.allTests[4].status, lu.NodeStatus.FAIL ) - lu.assertIsString( runner.result.allTests[4].msg ) - lu.assertIsString( runner.result.allTests[4].stackTrace ) - - lu.assertEquals( runner.result.errorTests[1].testName, 'MyTestWithErrorsAndFailures.testWithError1' ) - lu.assertEquals( runner.result.errorTests[1].className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( runner.result.errorTests[1].status, lu.NodeStatus.ERROR ) - lu.assertIsString( runner.result.errorTests[1].msg ) - lu.assertIsString( runner.result.errorTests[1].stackTrace ) - - lu.assertEquals( runner.result.failedTests[1].testName, 'MyTestWithErrorsAndFailures.testWithFailure1' ) - lu.assertEquals( runner.result.failedTests[1].className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( runner.result.failedTests[1].status, lu.NodeStatus.FAIL ) - lu.assertIsString( runner.result.failedTests[1].msg ) - lu.assertIsString( runner.result.failedTests[1].stackTrace ) - - lu.assertEquals( runner.result.failedTests[2].testName, 'MyTestWithErrorsAndFailures.testWithFailure2' ) - lu.assertEquals( runner.result.failedTests[2].className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( runner.result.failedTests[2].status, lu.NodeStatus.FAIL ) - lu.assertIsString( runner.result.failedTests[2].msg ) - lu.assertIsString( runner.result.failedTests[2].stackTrace ) - - end - - function TestLuaUnitResults:test_resultsWhileTestInProgress() - local MyMocker = { __class__ = "MyMocker" } - -- MyMocker is an outputter that creates a customized "Mock" instance - function MyMocker.new(runner) - local t = Mock.new(runner) - function t:startTest( _ ) - local node = self.result.currentNode - if node.number == 1 then - lu.assertEquals( node.number, 1 ) - lu.assertEquals( node.testName, 'MyTestWithErrorsAndFailures.testOk' ) - lu.assertEquals( node.className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( node.status, lu.NodeStatus.SUCCESS ) - elseif node.number == 2 then - lu.assertEquals( node.number, 2 ) - lu.assertEquals( node.testName, 'MyTestWithErrorsAndFailures.testWithError1' ) - lu.assertEquals( node.className, 'MyTestWithErrorsAndFailures' ) - lu.assertEquals( node.status, lu.NodeStatus.SUCCESS ) - end - end - function t:endTest( node ) - lu.assertEquals( node, self.result.currentNode ) - if node.number == 1 then - lu.assertEquals( node.status, lu.NodeStatus.SUCCESS ) - elseif node.number == 2 then - lu.assertEquals( node.status, lu.NodeStatus.ERROR ) - end - end - return t - end - - local runner = lu.LuaUnit.new() - runner.outputType = MyMocker - runner:runSuite( 'MyTestWithErrorsAndFailures' ) - - local m = runner.output - lu.assertEquals( m.calls[1][1], 'startSuite' ) - lu.assertEquals(#m.calls[1], 2 ) - end - - --- To execute me , use: lua run_unit_tests.lua |