lunit-tests.lua

   1
   2 --[[--------------------------------------------------------------------------
   3
   4     This file is part of lunit 0.4.
   5
   6     For Details about lunit look at: http://www.mroth.net/lunit/
   7
   8     Author: Michael Roth <mroth@nessie.de>
   9
  10     Copyright (c) 2004, 2006-2009 Michael Roth <mroth@nessie.de>
  11
  12     Permission is hereby granted, free of charge, to any person
  13     obtaining a copy of this software and associated documentation
  14     files (the "Software"), to deal in the Software without restriction,
  15     including without limitation the rights to use, copy, modify, merge,
  16     publish, distribute, sublicense, and/or sell copies of the Software,
  17     and to permit persons to whom the Software is furnished to do so,
  18     subject to the following conditions:
  19
  20     The above copyright notice and this permission notice shall be
  21     included in all copies or substantial portions of the Software.
  22
  23     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  26     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  27     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  28     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  29     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30
  31 --]]--------------------------------------------------------------------------
  32
  33
  34 require "lunit"
  35
  36
  37 local a_number    = 123
  38 local a_string    = "A string"
  39 local a_table     = { }
  40 local a_function  = function() end
  41 local a_thread    = coroutine.create(function() end)
  42
  43 local pcall       = pcall
  44 local error       = error
  45 local pairs       = pairs
  46 local ipairs      = ipairs
  47
  48 local module      = module
  49
  50
  51
  52 module( "lunit-tests.interface", lunit.testcase )
  53
  54 function test()
  55   local funcnames = {
  56     "main", "run", "runtest", "testcase", "testcases", "tests", "setupname",
  57     "teardownname", "loadrunner", "setrunner", "loadonly",
  58     "assert", "assert_true", "assert_false", "assert_equal", "assert_not_equal",
  59     "assert_match", "assert_not_match", "assert_nil", "assert_not_nil",
  60     "assert_boolean", "assert_not_boolean", "assert_number", "assert_not_number",
  61     "assert_string", "assert_not_string", "assert_table", "assert_not_table",
  62     "assert_function", "assert_not_function", "assert_thread", "assert_not_thread",
  63     "assert_userdata", "assert_not_userdata", "assert_pass", "assert_error",
  64     "assert_error_match", "fail", "clearstats",
  65     "is_nil", "is_boolean", "is_number", "is_string", "is_table", "is_function",
  66     "is_thread", "is_userdata"
  67   }
  68
  69   for _, funcname in ipairs(funcnames) do
  70     assert_function( lunit[funcname], "Public function missing: "..funcname )
  71   end
  72
  73   assert_table( lunit.stats, "Statistic table missing" )
  74
  75   do
  76     local map = {}
  77     for _, name in ipairs(funcnames) do
  78       map[name] = true
  79     end
  80     for _, name in ipairs{"lunit", "_PACKAGE", "_M", "_NAME", "stats"} do
  81       map[name] = true
  82     end
  83     for name, _ in pairs(lunit) do
  84       assert( map[name], "Invalid public variable: lunit."..name )
  85     end
  86   end
  87 end
  88
  89
  90
  91 -- We must assume that errors thrown by test functions are detected. We use
  92 -- the stdlib error() function to signal errors instead of fail().
  93 module( "lunit-tests.basics", lunit.testcase )
  94
  95 function test_fail()
  96   local ok, errmsg
  97
  98   ok, errmsg = pcall(function() fail() end)
  99   if ok then
 100     error("fail() doesn't fail!")
 101   end
 102
 103   ok, errmsg = pcall(function() fail("A message") end)
 104   if ok then
 105     error("fail(\"A message\") doesn't fail!")
 106   end
 107 end
 108
 109 function test_assert_error()
 110   local ok, errmsg
 111
 112   ok, errmsg = pcall(function() assert_error(function() error("Error!") end) end)
 113   if not ok then
 114     error("assert_error( <error> ) doesn't work!")
 115   end
 116
 117   ok, errmsg = pcall(function() assert_error("A message", function() error("Error") end) end)
 118   if not ok then
 119     error("assert_error(\"A message\", <error>) doesn't work!")
 120   end
 121
 122   ok, errmsg = pcall(function() assert_error(function() end) end)
 123   if ok then
 124     error("assert_error( <no error> ) doesn't fail!")
 125   end
 126
 127   ok, errmsg = pcall(function() assert_error("A Message", function() end) end)
 128   if ok then
 129     error("assert_error(\"A message\", <no error>) doesn't fail!")
 130   end
 131 end
 132
 133 function test_assert_pass()
 134   local ok, errmsg
 135
 136   ok, errmsg = pcall(function() assert_pass(function() error("Error!") end) end)
 137   if ok then
 138     error("assert_pass( <error> ) doesn't fail!")
 139   end
 140
 141   ok, errmsg = pcall(function() assert_pass("A message", function() error("Error") end) end)
 142   if ok then
 143     error("assert_pass(\"A message\", <error>) doesn't fail!")
 144   end
 145
 146   ok, errmsg = pcall(function() assert_pass(function() end) end)
 147   if not ok then
 148     error("assert_pass( <no error> ) doesn't work!")
 149   end
 150
 151   ok, errmsg = pcall(function() assert_pass("A Message", function() end) end)
 152   if not ok then
 153     error("assert_pass(\"A message\", <no error>) doesn't work!")
 154   end
 155 end
 156
 157 function test_assert_true()
 158   assert_pass("assert_true(true) doesn't work!", function() assert_true(true) end)
 159   assert_pass("assert_true(true, \"A message\" doesn't work!", function() assert_true(true, "A Message") end)
 160   assert_error("assert_true(false) doesn't fail!", function() assert_true(false) end)
 161   assert_error("assert_true(false, \"A message\" doesn't fail!", function() assert_true(false, "A Message") end)
 162 end
 163
 164 function test_assert_false()
 165   assert_pass("assert_false(false) doesn't work!", function() assert_false(false) end)
 166   assert_pass("assert_false(false, \"A message\" doesn't work!", function() assert_false(false, "A Message") end)
 167   assert_error("assert_false(true) doesn't fail!", function() assert_false(true) end)
 168   assert_error("assert_false(true, \"A message\" doesn't fail!", function() assert_false(true, "A Message") end)
 169 end
 170
 171 function test_assert()
 172   assert_pass("assert(true) doesn't work!", function() assert(true) end)
 173   assert_pass("assert(12345) doesn't work!", function() assert(12345) end)
 174   assert_pass("assert(\"A string\") doesn't work!", function() assert("A string") end)
 175   assert_pass("assert( {} ) doesn't work!", function() assert( {} ) end)
 176   assert_error("assert_(false) doesn't fail!", function() assert(false) end)
 177   assert_error("assert_(nil) doesn't fail!", function() assert(nil) end)
 178 end
 179
 180 function test_assert_equal()
 181   assert_pass("assert_equal(\"A String\", \"A String\") doesn't work!", function()
 182     local a_string = assert_equal("A String", "A String")
 183     assert_true("A String" == a_string)
 184   end)
 185
 186   assert_pass("assert_equal(\"A String\", \"A String\", \"A message\") doesn't work!", function()
 187     local a_string = assert_equal("A String", "A String", "A message")
 188     assert_true("A String" == a_string)
 189   end)
 190
 191   assert_pass("assert_equal(12345, 12345) doesn't work!", function()
 192     local a_number = assert_equal(12345, 12345)
 193     assert_true(12345 == a_number)
 194   end)
 195
 196   assert_pass("assert_equal(12345, 12345, \"A message\") doesn't work!", function()
 197     local a_number = assert_equal(12345, 12345, "A message")
 198     assert_true(12345 == a_number)
 199   end)
 200
 201   assert_pass("assert_equal(nil, nil) doesn't work!", function()
 202     local a_nil = assert_equal(nil, nil)
 203     assert_true(nil == a_nil)
 204   end)
 205
 206   assert_pass("assert_equal(12345, 12345, \"A message\") doesn't work!", function()
 207     local a_nil = assert_equal(nil, nil, "A message")
 208     assert_true(nil == a_nil)
 209   end)
 210
 211   assert_pass("assert_equal(false, false) doesn't work!", function()
 212     local a_false = assert_equal(false, false)
 213     assert_true(false == a_false)
 214   end)
 215
 216   assert_pass("assert_equal(false, false, \"A message\") doesn't work!", function()
 217     local a_false = assert_equal(false, false, "A message")
 218     assert_true(false == a_false)
 219   end)
 220
 221   assert_pass("assert_equal(true, true) doesn't work!", function()
 222     local a_true = assert_equal(true, true)
 223     assert_true(true == a_true)
 224   end)
 225
 226   assert_pass("assert_equal(true, true, \"A message\") doesn't work!", function()
 227     local a_true = assert_equal(true, true, "A message")
 228     assert_true(true == a_true)
 229   end)
 230
 231   assert_error("assert_equal(\"A String\", \"Another String\") doesn't fail!", function()
 232     assert_equal("A String", "Another String")
 233   end)
 234
 235   assert_error("assert_equal(\"A String\", \"Another String\", \"A message\") doesn't fail!", function()
 236     assert_equal("A String", "Another String", "A message")
 237   end)
 238
 239   assert_error("assert_equal(123, 456) doesn't fail!", function()
 240     assert_equal(123, 456)
 241   end)
 242
 243   assert_error("assert_equal(123, 456) \"A message\") doesn't fail!", function()
 244     assert_equal(123, 456, "A message")
 245   end)
 246
 247   assert_error("assert_equal(true, false) doesn't fail!", function()
 248     assert_equal(true, false)
 249   end)
 250
 251   assert_error("assert_equal(true, false) \"A message\") doesn't fail!", function()
 252     assert_equal(true, false, "A message")
 253   end)
 254
 255   assert_error("assert_equal(true, nil) doesn't fail!", function()
 256     assert_equal(true, nil)
 257   end)
 258
 259   assert_error("assert_equal(true, nil) \"A message\") doesn't fail!", function()
 260     assert_equal(true, nil, "A message")
 261   end)
 262
 263   assert_error("assert_equal(false, true) doesn't fail!", function()
 264     assert_equal(false, true)
 265   end)
 266
 267   assert_error("assert_equal(false, true, \"A message\") doesn't fail!", function()
 268     assert_equal(false, true, "A message")
 269   end)
 270
 271   assert_error("assert_equal(false, nil) doesn't fail!", function()
 272     assert_equal(false, nil)
 273   end)
 274
 275   assert_error("assert_equal(false, nil) \"A message\") doesn't fail!", function()
 276     assert_equal(false, nil, "A message")
 277   end)
 278
 279   assert_error("assert_equal(nil, true) doesn't fail!", function()
 280     assert_equal(nil, true)
 281   end)
 282
 283   assert_error("assert_equal(nil, true) \"A message\") doesn't fail!", function()
 284     assert_equal(nil, true, "A message")
 285   end)
 286
 287   assert_error("assert_equal(nil, false) doesn't fail!", function()
 288     assert_equal(nil, false)
 289   end)
 290
 291   assert_error("assert_equal(nil, false) \"A message\") doesn't fail!", function()
 292     assert_equal(nil, false, "A message")
 293   end)
 294 end
 295
 296
 297 function test_assert_not_equal()
 298   assert_pass("assert_not_equal(\"A String\", \"Another String\") doesn't work!", function()
 299     local a_string = assert_not_equal("A String", "Another String")
 300     assert_true("Another String" == a_string)
 301   end)
 302
 303   assert_pass("assert_not_equal(\"A String\", \"Another String\", \"A message\") doesn't work!", function()
 304     local a_string = assert_not_equal("A String", "Another String", "A message")
 305     assert_true("Another String" == a_string)
 306   end)
 307
 308   assert_pass("assert_not_equal(123, 456) doesn't work!", function()
 309     local a_number = assert_not_equal(123, 456)
 310     assert_true(456 == a_number)
 311   end)
 312
 313   assert_pass("assert_not_equal(123, 456, \"A message\") doesn't work!", function()
 314     local a_number = assert_not_equal(123, 456, "A message")
 315     assert_true(456 == a_number)
 316   end)
 317
 318   assert_pass("assert_not_equal(true, false) doesn't work!", function()
 319     local a_false = assert_not_equal(true, false)
 320     assert_true(false == a_false)
 321   end)
 322
 323   assert_pass("assert_not_equal(true, false) \"A message\") doesn't work!", function()
 324     local a_false = assert_not_equal(true, false, "A message")
 325     assert_true(false == a_false)
 326   end)
 327
 328   assert_pass("assert_not_equal(true, nil) doesn't work!", function()
 329     local a_nil = assert_not_equal(true, nil)
 330     assert_true(nil == a_nil)
 331   end)
 332
 333   assert_pass("assert_not_equal(true, nil) \"A message\") doesn't work!", function()
 334     local a_nil = assert_not_equal(true, nil, "A message")
 335     assert_true(nil == a_nil)
 336   end)
 337
 338   assert_pass("assert_not_equal(false, true) doesn't work!", function()
 339     local a_true = assert_not_equal(false, true)
 340     assert_true(true == a_true)
 341   end)
 342
 343   assert_pass("assert_not_equal(false, true, \"A message\") doesn't work!", function()
 344     local a_true = assert_not_equal(false, true, "A message")
 345     assert_true(true == a_true)
 346   end)
 347
 348   assert_pass("assert_not_equal(false, nil) doesn't work!", function()
 349     local a_nil = assert_not_equal(false, nil)
 350     assert_true(nil == a_nil)
 351   end)
 352
 353   assert_pass("assert_not_equal(false, nil) \"A message\") doesn't work!", function()
 354     local a_nil = assert_not_equal(false, nil, "A message")
 355     assert_true(nil == a_nil)
 356   end)
 357
 358   assert_pass("assert_not_equal(nil, true) doesn't work!", function()
 359     local a_true = assert_not_equal(nil, true)
 360     assert_true(true == a_true)
 361   end)
 362
 363   assert_pass("assert_not_equal(nil, true) \"A message\") doesn't work!", function()
 364     local a_true = assert_not_equal(nil, true, "A message")
 365     assert_true(true == a_true)
 366   end)
 367
 368   assert_pass("assert_not_equal(nil, false) doesn't work!", function()
 369     local a_false = assert_not_equal(nil, false)
 370     assert_true(false == a_false)
 371   end)
 372
 373   assert_pass("assert_not_equal(nil, false) \"A message\") doesn't work!", function()
 374     local a_false = assert_not_equal(nil, false, "A message")
 375     assert_true(false == a_false)
 376   end)
 377
 378   assert_error("assert_not_equal(\"A String\", \"A String\") doesn't work!", function()
 379     assert_not_equal("A String", "A String")
 380   end)
 381
 382   assert_error("assert_not_equal(\"A String\", \"A String\", \"A message\") doesn't fail!", function()
 383     assert_not_equal("A String", "A String", "A message")
 384   end)
 385
 386   assert_error("assert_not_equal(12345, 12345) doesn't fail!", function()
 387     assert_not_equal(12345, 12345)
 388   end)
 389
 390   assert_error("assert_not_equal(12345, 12345, \"A message\") doesn't fail!", function()
 391     assert_not_equal(12345, 12345, "A message")
 392   end)
 393
 394   assert_error("assert_not_equal(nil, nil) doesn't fail!", function()
 395     assert_not_equal(nil, nil)
 396   end)
 397
 398   assert_error("assert_not_equal(nil, nil, \"A message\") doesn't fail!", function()
 399     assert_not_equal(nil, nil, "A message")
 400   end)
 401
 402   assert_error("assert_not_equal(false, false) doesn't fail!", function()
 403     assert_not_equal(false, false)
 404   end)
 405
 406   assert_error("assert_not_equal(false, false, \"A message\") doesn't fail!", function()
 407     assert_not_equal(false, false, "A message")
 408   end)
 409
 410   assert_error("assert_not_equal(true, true) doesn't fail!", function()
 411     assert_not_equal(true, true)
 412   end)
 413
 414   assert_error("assert_not_equal(true, true, \"A message\") doesn't fail!", function()
 415     assert_not_equal(true, true, "A message")
 416   end)
 417 end
 418
 419
 420
 421 module( "lunit-tests.is_xyz", lunit.testcase )
 422
 423 function test_is_nil()
 424   assert_true( is_nil(nil) )
 425   assert_false( is_nil(true) )
 426   assert_false( is_nil(false) )
 427   assert_false( is_nil(a_number) )
 428   assert_false( is_nil(a_string) )
 429   assert_false( is_nil(a_table) )
 430   assert_false( is_nil(a_function) )
 431   assert_false( is_nil(a_thread) )
 432 end
 433
 434 function test_is_boolean()
 435   assert_true( is_boolean(false) )
 436   assert_true( is_boolean(true) )
 437   assert_false( is_boolean(nil) )
 438   assert_false( is_boolean(a_number) )
 439   assert_false( is_boolean(a_string) )
 440   assert_false( is_boolean(a_table) )
 441   assert_false( is_boolean(a_function) )
 442   assert_false( is_boolean(a_thread) )
 443 end
 444
 445 function test_is_number()
 446   assert_true( is_number(a_number) )
 447   assert_false( is_number(nil) )
 448   assert_false( is_number(true) )
 449   assert_false( is_number(false) )
 450   assert_false( is_number(a_string) )
 451   assert_false( is_number(a_table) )
 452   assert_false( is_number(a_function) )
 453   assert_false( is_number(a_thread) )
 454 end
 455
 456 function test_is_string()
 457   assert_true( is_string(a_string) )
 458   assert_false( is_string(nil) )
 459   assert_false( is_string(true) )
 460   assert_false( is_string(false) )
 461   assert_false( is_string(a_number) )
 462   assert_false( is_string(a_table) )
 463   assert_false( is_string(a_function) )
 464   assert_false( is_string(a_thread) )
 465 end
 466
 467 function test_is_table()
 468   assert_true( is_table(a_table) )
 469   assert_false( is_table(nil) )
 470   assert_false( is_table(true) )
 471   assert_false( is_table(false) )
 472   assert_false( is_table(a_number) )
 473   assert_false( is_table(a_string) )
 474   assert_false( is_table(a_function) )
 475   assert_false( is_table(a_thread) )
 476 end
 477
 478 function test_is_function()
 479   assert_true( is_function(a_function) )
 480   assert_false( is_function(nil) )
 481   assert_false( is_function(true) )
 482   assert_false( is_function(false) )
 483   assert_false( is_function(a_number) )
 484   assert_false( is_function(a_string) )
 485   assert_false( is_function(a_table) )
 486   assert_false( is_function(a_thread) )
 487 end
 488
 489 function test_is_thread()
 490   assert_true( is_thread(a_thread) )
 491   assert_false( is_thread(nil) )
 492   assert_false( is_thread(true) )
 493   assert_false( is_thread(false) )
 494   assert_false( is_thread(a_number) )
 495   assert_false( is_thread(a_string) )
 496   assert_false( is_thread(a_table) )
 497   assert_false( is_thread(a_function) )
 498 end
 499
 500
 501
 502 module( "lunit-tests.assert_not_xyz", lunit.testcase )
 503
 504 function test_assert_not_nil()
 505   assert_not_nil( true )
 506   assert_not_nil( false )
 507   assert_not_nil( a_number )
 508   assert_not_nil( a_string )
 509   assert_not_nil( a_table )
 510   assert_not_nil( a_function )
 511   assert_not_nil( a_thread )
 512
 513   assert_not_nil( true, "A message")
 514   assert_not_nil( false, "A message")
 515   assert_not_nil( a_number, "A message")
 516   assert_not_nil( a_string, "A message")
 517   assert_not_nil( a_table, "A message")
 518   assert_not_nil( a_function, "A message")
 519   assert_not_nil( a_thread, "A message")
 520
 521   assert_error(function() assert_not_nil(nil) end)
 522   assert_error(function() assert_not_nil(nil, "A message") end)
 523 end
 524
 525 function test_assert_not_boolean()
 526   assert_not_boolean( nil )
 527   assert_not_boolean( a_number )
 528   assert_not_boolean( a_string )
 529   assert_not_boolean( a_table )
 530   assert_not_boolean( a_function )
 531   assert_not_boolean( a_thread )
 532
 533   assert_not_boolean( nil, "A message")
 534   assert_not_boolean( a_number, "A message")
 535   assert_not_boolean( a_string, "A message")
 536   assert_not_boolean( a_table, "A message")
 537   assert_not_boolean( a_function, "A message")
 538   assert_not_boolean( a_thread, "A message")
 539
 540   assert_error(function() assert_not_boolean(true) end)
 541   assert_error(function() assert_not_boolean(true, "A message") end)
 542   assert_error(function() assert_not_boolean(false) end)
 543   assert_error(function() assert_not_boolean(false, "A message") end)
 544 end
 545
 546 function test_assert_not_number()
 547   assert_not_number( nil )
 548   assert_not_number( true )
 549   assert_not_number( false )
 550   assert_not_number( a_string )
 551   assert_not_number( a_table )
 552   assert_not_number( a_function )
 553   assert_not_number( a_thread )
 554
 555   assert_not_number( nil, "A message")
 556   assert_not_number( true, "A message")
 557   assert_not_number( false, "A message")
 558   assert_not_number( a_string, "A message")
 559   assert_not_number( a_table, "A message")
 560   assert_not_number( a_function, "A message")
 561   assert_not_number( a_thread, "A message")
 562
 563   assert_error(function() assert_not_number(a_number) end)
 564   assert_error(function() assert_not_number(a_number, "A message") end)
 565 end
 566
 567 function test_assert_not_string()
 568   assert_not_string( nil )
 569   assert_not_string( true )
 570   assert_not_string( false )
 571   assert_not_string( a_number )
 572   assert_not_string( a_table )
 573   assert_not_string( a_function )
 574   assert_not_string( a_thread )
 575
 576   assert_not_string( nil, "A message")
 577   assert_not_string( true, "A message")
 578   assert_not_string( false, "A message")
 579   assert_not_string( a_number, "A message")
 580   assert_not_string( a_table, "A message")
 581   assert_not_string( a_function, "A message")
 582   assert_not_string( a_thread, "A message")
 583
 584   assert_error(function() assert_not_string(a_string) end)
 585   assert_error(function() assert_not_string(a_string, "A message") end)
 586 end
 587
 588 function test_assert_not_table()
 589   assert_not_table( nil )
 590   assert_not_table( true )
 591   assert_not_table( false )
 592   assert_not_table( a_number )
 593   assert_not_table( a_string )
 594   assert_not_table( a_function )
 595   assert_not_table( a_thread )
 596
 597   assert_not_table( nil, "A message")
 598   assert_not_table( true, "A message")
 599   assert_not_table( false, "A message")
 600   assert_not_table( a_number, "A message")
 601   assert_not_table( a_string, "A message")
 602   assert_not_table( a_function, "A message")
 603   assert_not_table( a_thread, "A message")
 604
 605   assert_error(function() assert_not_table(a_table) end)
 606   assert_error(function() assert_not_table(a_table, "A message") end)
 607 end
 608
 609 function test_assert_not_function()
 610   assert_not_function( nil )
 611   assert_not_function( true )
 612   assert_not_function( false )
 613   assert_not_function( a_number )
 614   assert_not_function( a_string )
 615   assert_not_function( a_table )
 616   assert_not_function( a_thread )
 617
 618   assert_not_function( nil, "A message")
 619   assert_not_function( true, "A message")
 620   assert_not_function( false, "A message")
 621   assert_not_function( a_number, "A message")
 622   assert_not_function( a_string, "A message")
 623   assert_not_function( a_table, "A message")
 624   assert_not_function( a_thread, "A message")
 625
 626   assert_error(function() assert_not_function(a_function) end)
 627   assert_error(function() assert_not_function(a_function, "A message") end)
 628 end
 629
 630 function test_assert_not_thread()
 631   assert_not_thread( nil )
 632   assert_not_thread( true )
 633   assert_not_thread( false )
 634   assert_not_thread( a_number )
 635   assert_not_thread( a_string )
 636   assert_not_thread( a_table )
 637   assert_not_thread( a_function )
 638
 639   assert_not_thread( nil, "A message")
 640   assert_not_thread( true, "A message")
 641   assert_not_thread( false, "A message")
 642   assert_not_thread( a_number, "A message")
 643   assert_not_thread( a_string, "A message")
 644   assert_not_thread( a_table, "A message")
 645   assert_not_thread( a_function, "A message")
 646
 647   assert_error(function() assert_not_thread(a_thread) end)
 648   assert_error(function() assert_not_thread(a_thread, "A message") end)
 649 end
 650
 651
 652
 653 module( "lunit-tests.assert_xyz", lunit.testcase )
 654
 655 function test_assert_nil()
 656   assert_nil( nil )
 657   assert_nil( nil, "A message" )
 658
 659   assert_error( function() assert_nil( true ) end)
 660   assert_error( function() assert_nil( false ) end)
 661   assert_error( function() assert_nil( a_number ) end)
 662   assert_error( function() assert_nil( a_string ) end)
 663   assert_error( function() assert_nil( a_table ) end)
 664   assert_error( function() assert_nil( a_function ) end)
 665   assert_error( function() assert_nil( a_thread ) end)
 666
 667   assert_error( function() assert_nil( true, "A message" ) end)
 668   assert_error( function() assert_nil( false, "A message" ) end)
 669   assert_error( function() assert_nil( a_number, "A message" ) end)
 670   assert_error( function() assert_nil( a_string, "A message" ) end)
 671   assert_error( function() assert_nil( a_table, "A message" ) end)
 672   assert_error( function() assert_nil( a_function, "A message" ) end)
 673   assert_error( function() assert_nil( a_thread, "A message" ) end)
 674 end
 675
 676 function test_assert_boolean()
 677   assert_boolean( true )
 678   assert_boolean( false )
 679   assert_boolean( true, "A message" )
 680   assert_boolean( false, "A message" )
 681
 682   assert_error( function() assert_boolean( nil ) end)
 683   assert_error( function() assert_boolean( a_number ) end)
 684   assert_error( function() assert_boolean( a_string ) end)
 685   assert_error( function() assert_boolean( a_table ) end)
 686   assert_error( function() assert_boolean( a_function ) end)
 687   assert_error( function() assert_boolean( a_thread ) end)
 688
 689   assert_error( function() assert_boolean( nil, "A message" ) end)
 690   assert_error( function() assert_boolean( a_number, "A message" ) end)
 691   assert_error( function() assert_boolean( a_string, "A message" ) end)
 692   assert_error( function() assert_boolean( a_table, "A message" ) end)
 693   assert_error( function() assert_boolean( a_function, "A message" ) end)
 694   assert_error( function() assert_boolean( a_thread, "A message" ) end)
 695 end
 696
 697 function test_assert_number()
 698   assert_number( a_number )
 699   assert_number( a_number, "A message" )
 700
 701   assert_error( function() assert_number( nil ) end)
 702   assert_error( function() assert_number( true ) end)
 703   assert_error( function() assert_number( false ) end)
 704   assert_error( function() assert_number( a_string ) end)
 705   assert_error( function() assert_number( a_table ) end)
 706   assert_error( function() assert_number( a_function ) end)
 707   assert_error( function() assert_number( a_thread ) end)
 708
 709   assert_error( function() assert_number( nil, "A message" ) end)
 710   assert_error( function() assert_number( true, "A message" ) end)
 711   assert_error( function() assert_number( false, "A message" ) end)
 712   assert_error( function() assert_number( a_string, "A message" ) end)
 713   assert_error( function() assert_number( a_table, "A message" ) end)
 714   assert_error( function() assert_number( a_function, "A message" ) end)
 715   assert_error( function() assert_number( a_thread, "A message" ) end)
 716 end
 717
 718 function test_assert_string()
 719   assert_string( a_string )
 720   assert_string( a_string, "A message" )
 721
 722   assert_error( function() assert_string( nil ) end)
 723   assert_error( function() assert_string( true ) end)
 724   assert_error( function() assert_string( false ) end)
 725   assert_error( function() assert_string( a_number ) end)
 726   assert_error( function() assert_string( a_table ) end)
 727   assert_error( function() assert_string( a_function ) end)
 728   assert_error( function() assert_string( a_thread ) end)
 729
 730   assert_error( function() assert_string( nil, "A message" ) end)
 731   assert_error( function() assert_string( true, "A message" ) end)
 732   assert_error( function() assert_string( false, "A message" ) end)
 733   assert_error( function() assert_string( a_number, "A message" ) end)
 734   assert_error( function() assert_string( a_table, "A message" ) end)
 735   assert_error( function() assert_string( a_function, "A message" ) end)
 736   assert_error( function() assert_string( a_thread, "A message" ) end)
 737 end
 738
 739 function test_assert_table()
 740   assert_table( a_table )
 741   assert_table( a_table, "A message" )
 742
 743   assert_error( function() assert_table( nil ) end)
 744   assert_error( function() assert_table( true ) end)
 745   assert_error( function() assert_table( false ) end)
 746   assert_error( function() assert_table( a_number ) end)
 747   assert_error( function() assert_table( a_string ) end)
 748   assert_error( function() assert_table( a_function ) end)
 749   assert_error( function() assert_table( a_thread ) end)
 750
 751   assert_error( function() assert_table( nil, "A message" ) end)
 752   assert_error( function() assert_table( true, "A message" ) end)
 753   assert_error( function() assert_table( false, "A message" ) end)
 754   assert_error( function() assert_table( a_number, "A message" ) end)
 755   assert_error( function() assert_table( a_string, "A message" ) end)
 756   assert_error( function() assert_table( a_function, "A message" ) end)
 757   assert_error( function() assert_table( a_thread, "A message" ) end)
 758 end
 759
 760 function test_assert_function()
 761   assert_function( a_function )
 762   assert_function( a_function, "A message" )
 763
 764   assert_error( function() assert_function( nil ) end)
 765   assert_error( function() assert_function( true ) end)
 766   assert_error( function() assert_function( false ) end)
 767   assert_error( function() assert_function( a_number ) end)
 768   assert_error( function() assert_function( a_string ) end)
 769   assert_error( function() assert_function( a_table ) end)
 770   assert_error( function() assert_function( a_thread ) end)
 771
 772   assert_error( function() assert_function( nil, "A message" ) end)
 773   assert_error( function() assert_function( true, "A message" ) end)
 774   assert_error( function() assert_function( false, "A message" ) end)
 775   assert_error( function() assert_function( a_number, "A message" ) end)
 776   assert_error( function() assert_function( a_string, "A message" ) end)
 777   assert_error( function() assert_function( a_table, "A message" ) end)
 778   assert_error( function() assert_function( a_thread, "A message" ) end)
 779 end
 780
 781 function test_assert_thread()
 782   assert_thread( a_thread )
 783   assert_thread( a_thread, "A message" )
 784
 785   assert_error( function() assert_thread( nil ) end)
 786   assert_error( function() assert_thread( true ) end)
 787   assert_error( function() assert_thread( false ) end)
 788   assert_error( function() assert_thread( a_number ) end)
 789   assert_error( function() assert_thread( a_string ) end)
 790   assert_error( function() assert_thread( a_table ) end)
 791   assert_error( function() assert_thread( a_function ) end)
 792
 793   assert_error( function() assert_thread( nil, "A message" ) end)
 794   assert_error( function() assert_thread( true, "A message" ) end)
 795   assert_error( function() assert_thread( false, "A message" ) end)
 796   assert_error( function() assert_thread( a_number, "A message" ) end)
 797   assert_error( function() assert_thread( a_string, "A message" ) end)
 798   assert_error( function() assert_thread( a_table, "A message" ) end)
 799   assert_error( function() assert_thread( a_function, "A message" ) end)
 800 end
 801
 802
 803
 804 module( "lunit-tests.match", lunit.testcase )
 805
 806 function test_assert_match()
 807   assert_pass("assert_match(\"^Hello\", \"Hello World\") doesn't work!", function()
 808     local a_string = assert_match("^Hello", "Hello World")
 809     assert_equal("Hello World", a_string)
 810   end)
 811
 812   assert_pass("assert_match(\"^Hello\", \"Hello World\", \"A Message\") doesn't work!", function()
 813     local a_string = assert_match("^Hello", "Hello World", "A message")
 814     assert_equal("Hello World", a_string)
 815   end)
 816
 817   assert_pass("assert_match(\"World$\", \"Hello World\") doesn't work!", function()
 818     local a_string = assert_match("World$", "Hello World")
 819     assert_equal("Hello World", a_string)
 820   end)
 821
 822   assert_pass("assert_match(\"World$\", \"Hello World\", \"A Message\") doesn't work!", function()
 823     local a_string = assert_match("World$", "Hello World", "A message")
 824     assert_equal("Hello World", a_string)
 825   end)
 826
 827   assert_error("assert_match(\"Hello$\", \"Hello World\") doesn't fail!", function()
 828     assert_match("Hello$", "Hello World")
 829   end)
 830
 831   assert_error("assert_match(\"Hello$\", \"Hello World\", \"A Message\") doesn't fail!", function()
 832     assert_match("Hello$", "Hello World", "A message")
 833   end)
 834
 835   assert_error("assert_match(\"^World\", \"Hello World\") doesn't fail!", function()
 836     assert_match("^World", "Hello World")
 837   end)
 838
 839   assert_error("assert_match(\"^World\", \"Hello World\", \"A Message\") doesn't fail!", function()
 840     assert_match("^World", "Hello World", "A message")
 841   end)
 842
 843   assert_error("assert_match(nil, \"Hello World\") doesn't fail!", function()
 844     assert_match(nil, "Hello World")
 845   end)
 846
 847   assert_error("assert_match(nil, \"Hello World\", \"A Message\") doesn't fail!", function()
 848     assert_match(nil, "Hello World", "A message")
 849   end)
 850
 851   assert_error("assert_match(\"^World\", nil) doesn't fail!", function()
 852     assert_match("^World", nil)
 853   end)
 854
 855   assert_error("assert_match(\"^World\", nil, \"A Message\") doesn't fail!", function()
 856     assert_match("^World", nil, "A message")
 857   end)
 858 end
 859
 860 function test_assert_not_match()
 861   assert_pass("assert_not_match(\"Hello$\", \"Hello World\") doesn't work!", function()
 862     local a_string = assert_not_match("Hello$", "Hello World")
 863     assert_equal("Hello World", a_string)
 864   end)
 865
 866   assert_pass("assert_not_match(\"Hello$\", \"Hello World\", \"A Message\") doesn't work!", function()
 867     local a_string = assert_not_match("Hello$", "Hello World", "A message")
 868     assert_equal("Hello World", a_string)
 869   end)
 870
 871   assert_pass("assert_not_match(\"^World\", \"Hello World\") doesn't work!", function()
 872     local a_string = assert_not_match("^World", "Hello World")
 873     assert_equal("Hello World", a_string)
 874   end)
 875
 876   assert_pass("assert_not_match(\"^World\", \"Hello World\", \"A Message\") doesn't work!", function()
 877     local a_string = assert_not_match("^World", "Hello World", "A message")
 878     assert_equal("Hello World", a_string)
 879   end)
 880
 881   assert_error("assert_not_match(\"^Hello\", \"Hello World\") doesn't fail!", function()
 882     assert_not_match("^Hello", "Hello World")
 883   end)
 884
 885   assert_error("assert_not_match(\"^Hello\", \"Hello World\", \"A Message\") doesn't fail!", function()
 886     assert_not_match("^Hello", "Hello World", "A message")
 887   end)
 888
 889   assert_error("assert_not_match(\"World$\", \"Hello World\") doesn't fail!", function()
 890     assert_not_match("World$", "Hello World")
 891   end)
 892
 893   assert_error("assert_not_match(\"World$\", \"Hello World\", \"A Message\") doesn't fail!", function()
 894     assert_not_match("World$", "Hello World", "A message")
 895   end)
 896
 897   assert_error("assert_not_match(nil, \"Hello World\") doesn't fail!", function()
 898     assert_not_match(nil, "Hello World")
 899   end)
 900
 901   assert_error("assert_not_match(nil, \"Hello World\", \"A Message\") doesn't fail!", function()
 902     assert_not_match(nil, "Hello World", "A message")
 903   end)
 904
 905   assert_error("assert_not_match(\"^World\", nil) doesn't fail!", function()
 906     assert_not_match("^World", nil)
 907   end)
 908
 909   assert_error("assert_not_match(\"^World\", nil, \"A Message\") doesn't fail!", function()
 910     assert_not_match("^World", nil, "A message")
 911   end)
 912 end
 913
 914 function test_assert_error_match()
 915   local ok, errobj, usrmsg
 916
 917   local function errfunc()
 918     error("My Error!")
 919   end
 920
 921   local errpattern = "Error!$"
 922   local wrongpattern = "^_foobar_$"
 923
 924   local function goodfunc()
 925     -- NOP
 926   end
 927
 928   ok = pcall(function() assert_error_match(errpattern, errfunc) end)
 929   assert_true(ok, "assert_error_match( <pattern>, <error> )")
 930
 931   ok = pcall(function() assert_error_match("A message", errpattern, errfunc) end)
 932   assert_true(ok, "assert_error_match(\"A message\", <pattern>, <error>)")
 933
 934   usrmsg = "assert_error_match( <wrong pattern>, <error> )"
 935   ok, errobj = pcall(function() assert_error_match(wrongpattern, errfunc) end)
 936   assert_false(ok, usrmsg)
 937   assert_table(errobj, usrmsg)
 938   assert_match("expected error '.+: My Error!' to match pattern '"..wrongpattern.."' but doesn't$", errobj.msg, usrmsg)
 939
 940   usrmsg = "assert_error_match(\"A message\", <wrong pattern>, <error>)"
 941   ok, errobj = pcall(function() assert_error_match("A message", wrongpattern, errfunc) end)
 942   assert_false(ok, usrmsg)
 943   assert_table(errobj, usrmsg)
 944   assert_match("expected error '.+: My Error!' to match pattern '"..wrongpattern.."' but doesn't$", errobj.msg, usrmsg)
 945
 946   usrmsg = "assert_error_match( <pattern>, <no error> )"
 947   ok, errobj = pcall(function() assert_error_match(errpattern, goodfunc) end)
 948   assert_false(ok, usrmsg)
 949   assert_table(errobj, usrmsg)
 950   assert_match("error expected but no error occurred$", errobj.msg, usrmsg)
 951
 952   usrmsg = "assert_error_match(\"A message\", <pattern>, <no error>)"
 953   ok, errobj = pcall(function() assert_error_match("A Message", errpattern, goodfunc) end)
 954   assert_false(ok, usrmsg)
 955   assert_table(errobj, usrmsg)
 956   assert_match("error expected but no error occurred$", errobj.msg, usrmsg)
 957 end
 958
 959
 960
 961 module( "lunit-tests.setup-teardown", lunit.testcase )
 962
 963 local setup_called = 0
 964 local teardown_called = 0
 965 local helper_called = 0
 966
 967 function setup()
 968   setup_called = setup_called + 1
 969 end
 970
 971 function Teardown()
 972   teardown_called = teardown_called + 1
 973 end
 974
 975 local function helper()
 976   helper_called = helper_called + 1
 977   assert(setup_called == helper_called, "setup() not called")
 978   assert(teardown_called == helper_called - 1, "teardown() not called")
 979 end
 980
 981 function test1()
 982   helper()
 983 end
 984
 985 function test2()
 986   helper()
 987 end
 988
 989 function test3()
 990   helper()
 991 end