diff options
Diffstat (limited to 'Data/Libraries/luaunit/test/compat_luaunit_v2x.lua')
| -rw-r--r-- | Data/Libraries/luaunit/test/compat_luaunit_v2x.lua | 175 |
1 files changed, 175 insertions, 0 deletions
diff --git a/Data/Libraries/luaunit/test/compat_luaunit_v2x.lua b/Data/Libraries/luaunit/test/compat_luaunit_v2x.lua new file mode 100644 index 0000000..2fc7ef8 --- /dev/null +++ b/Data/Libraries/luaunit/test/compat_luaunit_v2x.lua @@ -0,0 +1,175 @@ +EXPORT_ASSERT_TO_GLOBALS = true +local lu = require('luaunit') + +--[[ +Use Luaunit in the v2.1 fashion and check that it still works. +Exercise every luaunit v2.1 function and have it executed successfully. + +Coverage: +x Made LuaUnit:run() method able to be called with 'run' or 'Run'. +x Made LuaUnit.wrapFunctions() function able to be called with 'wrapFunctions' or 'WrapFunctions' or 'wrap_functions'. +x Moved wrapFunctions to the LuaUnit module table (e.g. local LuaUnit = require( "luaunit" ); LuaUnit.wrapFunctions( ... ) ) +x Added LuaUnit.is<Type> and LuaUnit.is_<type> helper functions. (e.g. assert( LuaUnit.isString( getString() ) ) +x Added assert<Type> and assert_<type> +x Added assertNot<Type> and assert_not_<type> +x Added _VERSION variable to hold the LuaUnit version +x Added LuaUnit:setVerbosity(lvl) method to the LuaUnit. Alias: LuaUnit:SetVerbosity() and LuaUnit:set_verbosity(). +x Added table deep compare +x check that wrapFunctions works +x Made "testable" classes able to start with 'test' or 'Test' for their name. +x Made "testable" methods able to start with 'test' or 'Test' for their name. +x Made testClass:setUp() methods able to be named with 'setUp' or 'Setup' or 'setup'. +x Made testClass:tearDown() methods able to be named with 'tearDown' or 'TearDown' or 'teardown'. +]] + + +TestLuaUnitV2Compat = {} + +function TestLuaUnitV2Compat:testRunAliases() + -- some old function + assertFunction( lu.run ) + assertEquals( lu.Run, lu.run ) +end + +function TestLuaUnitV2Compat:testWrapFunctionsAliases() + assertFunction( lu.wrapFunctions ) + assertEquals( lu.wrapFunctions, lu.WrapFunctions ) + assertEquals( lu.wrapFunctions, lu.wrap_functions ) +end + +local function typeAsserter( goodType, badType, goodAsserter, badAsserter ) + goodAsserter( goodType ) + if badAsserter ~= nil then + badAsserter( badType ) + end +end + +function TestLuaUnitV2Compat:testAssertType() + local f = function (v) return v+1 end + local t = coroutine.create( function(v) local y=v+1 end ) + local typesToVerify = { + -- list of: { goodType, badType, goodAsserter, badAsserter } + { true, "toto", assertBoolean, assertNotBoolean }, + { true, "toto", assert_boolean, assert_not_boolean }, + { 1 , "toto", assertNumber, assertNotNumber }, + { 1 , "toto", assert_number, assert_not_number }, + { "q" , 1 , assertString, assertNotString }, + { "q" , 1 , assert_string, assert_not_string }, + { nil , 1 , assertNil, assertNotNil }, + { nil , 1 , assert_nil, assert_not_nil }, + { {1,2}, "toto", assertTable, assertNotTable }, + { {1,2}, "toto", assert_table, assert_not_table }, + { f , "toto", assertFunction, assertNotFunction }, + { f , "toto", assert_function,assert_not_function }, + { t , "toto", assertThread, assertNotThread }, + { t , "toto", assert_thread, assert_not_thread }, + + } + + for _,v in ipairs( typesToVerify ) do + local goodType, badType, goodAsserter, badAsserter = v[1], v[2], v[3], v[4] + typeAsserter( goodType, badType, goodAsserter, badAsserter ) + end + + assertNotUserdata( "toto" ) + + + local typesToVerify2 = { + { true, "toto", lu.isBoolean }, + { true, "toto", lu.is_boolean }, + { 1, "toto", lu.isNumber }, + { 1, "toto", lu.is_number }, + { "t", 1, lu.isString }, + { "t", 1, lu.is_string }, + { nil, "toto", lu.isNil }, + { nil, "toto", lu.is_nil }, + { {1,2},"toto", lu.isTable }, + { {1,2},"toto", lu.is_table }, + { f, "toto", lu.isFunction }, + { f, "toto", lu.is_function }, + { t, "toto", lu.isThread }, + { t, "toto", lu.is_thread }, + } + + for _,v in ipairs( typesToVerify2 ) do + local goodType, badType, goodTypeVerifier = v[1], v[2], v[3] + if (v[3] == nil) then + print('Missing function at index '.._) + assertNotNil( v[3] ) + end + assertTrue ( goodTypeVerifier( goodType ) ) + assertFalse( goodTypeVerifier( badType ) ) + end + +end + +function TestLuaUnitV2Compat:testHasVersionKey() + assertNotNil( lu.VERSION ) + assertString( lu.VERSION ) + assertNotNil( lu._VERSION ) + assertTrue( lu.is_string( lu._VERSION ) ) +end + +function TestLuaUnitV2Compat:testTableEquality() + local t1 = {1,2} + local t2 = t1 + local t3 = {1,2} + local t4 = {1,2,3} + + assertEquals( t1, t1 ) + assertEquals( t1, t2 ) + -- new in LuaUnit v2.0 , deep table compare + assertEquals( t1, t3 ) + assertError( assertEquals, t1, t4 ) +end + +-- Setup +local called = {} + +function test_w1() called.w1 = true end +function test_w2() called.w2 = true end +function test_w3() called.w3 = true end + +TestSomeFuncs = lu.wrapFunctions( 'test_w1', 'test_w2', 'test_w3' ) + +TestWithCap = {} +function TestWithCap:setup() called.setup = true end +function TestWithCap:Test1() called.t1 = true end +function TestWithCap:test2() called.t2 = true end +function TestWithCap:teardown() called.teardown = true end + +testWithoutCap = {} +function testWithoutCap:Setup() called.Setup = true end +function testWithoutCap:Test3() called.t3 = true end +function testWithoutCap:test4() called.t4 = true end +function testWithoutCap:tearDown() called.tearDown = true end + +TestWithUnderscore = {} +function TestWithUnderscore:setUp() called.setUp = true end +function TestWithUnderscore:Test1() called.t1 = true end +function TestWithUnderscore:test2() called.t2 = true end +function TestWithUnderscore:TearDown() called.TearDown = true end + +-- Run +lu:setVerbosity( 1 ) +lu:set_verbosity( 1 ) +lu:SetVerbosity( 1 ) + +local results = lu.run() + +-- Verif +assert( called.w1 == true ) +assert( called.w2 == true ) +assert( called.w3 == true ) +assert( called.t1 == true ) +assert( called.t2 == true ) +assert( called.t3 == true ) +assert( called.t4 == true ) +assert( called.setup == true ) +assert( called.setUp == true ) +assert( called.Setup == true ) +assert( called.teardown == true ) +assert( called.tearDown == true ) +assert( called.TearDown == true ) + +os.exit( results ) |