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-2008 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_error_match()
 134   local ok, errmsg
 135
 136   local function errfunc()
 137     error("Error!")
 138   end
 139
 140   local errpattern = "Error!$"
 141   local wrongpattern = "^_foobar_$"
 142
 143   local function goodfunc()
 144     -- NOP
 145   end
 146
 147   ok, errmsg = pcall(function() assert_error_match(errpattern, errfunc) end)
 148   if not ok then
 149     error("assert_error_match( <pattern>, <error> ) doesn't work!")
 150   end
 151
 152   ok, errmsg = pcall(function() assert_error_match("A message", errpattern, errfunc) end)
 153   if not ok then
 154     error("assert_error_match(\"A message\", <pattern>, <error>) doesn't work!")
 155   end
 156
 157   ok, errmsg = pcall(function() assert_error_match(wrongpattern, errfunc) end)
 158   if ok then
 159     error("assert_error_match( <wrong pattern>, <error> ) doesn't work!")
 160   end
 161
 162   ok, errmsg = pcall(function() assert_error_match("A message", wrongpattern, errfunc) end)
 163   if ok then
 164     error("assert_error_match(\"A message\", <wrong pattern>, <error>) doesn't work!")
 165   end
 166
 167   ok, errmsg = pcall(function() assert_error_match(errpattern, goodfunc) end)
 168   if ok then
 169     error("assert_error_match( <pattern>, <no error> ) doesn't fail!")
 170   end
 171
 172   ok, errmsg = pcall(function() assert_error_match("A Message", errpatern, goodfunc) end)
 173   if ok then
 174     error("assert_error_match(\"A message\", <pattern>, <no error>) doesn't fail!")
 175   end
 176 end
 177
 178 function test_assert_pass()
 179   local ok, errmsg
 180
 181   ok, errmsg = pcall(function() assert_pass(function() error("Error!") end) end)
 182   if ok then
 183     error("assert_pass( <error> ) doesn't fail!")
 184   end
 185
 186   ok, errmsg = pcall(function() assert_pass("A message", function() error("Error") end) end)
 187   if ok then
 188     error("assert_pass(\"A message\", <error>) doesn't fail!")
 189   end
 190
 191   ok, errmsg = pcall(function() assert_pass(function() end) end)
 192   if not ok then
 193     error("assert_pass( <no error> ) doesn't work!")
 194   end
 195
 196   ok, errmsg = pcall(function() assert_pass("A Message", function() end) end)
 197   if not ok then
 198     error("assert_pass(\"A message\", <no error>) doesn't work!")
 199   end
 200 end
 201
 202 function test_assert_true()
 203   assert_pass("assert_true(true) doesn't work!", function() assert_true(true) end)
 204   assert_pass("assert_true(true, \"A message\" doesn't work!", function() assert_true(true, "A Message") end)
 205   assert_error("assert_true(false) doesn't fail!", function() assert_true(false) end)
 206   assert_error("assert_true(false, \"A message\" doesn't fail!", function() assert_true(false, "A Message") end)
 207 end
 208
 209 function test_assert_false()
 210   assert_pass("assert_false(false) doesn't work!", function() assert_false(false) end)
 211   assert_pass("assert_false(false, \"A message\" doesn't work!", function() assert_false(false, "A Message") end)
 212   assert_error("assert_false(true) doesn't fail!", function() assert_false(true) end)
 213   assert_error("assert_false(true, \"A message\" doesn't fail!", function() assert_false(true, "A Message") end)
 214 end
 215
 216 function test_assert()
 217   assert_pass("assert(true) doesn't work!", function() assert(true) end)
 218   assert_pass("assert(12345) doesn't work!", function() assert(12345) end)
 219   assert_pass("assert(\"A string\") doesn't work!", function() assert("A string") end)
 220   assert_pass("assert( {} ) doesn't work!", function() assert( {} ) end)
 221   assert_error("assert_(false) doesn't fail!", function() assert(false) end)
 222   assert_error("assert_(nil) doesn't fail!", function() assert(nil) end)
 223 end
 224
 225 function test_assert_equal()
 226
 227   assert_pass("assert_equal(\"A String\", \"A String\") doesn't work!", function()
 228     local a_string = assert_equal("A String", "A String")
 229     assert_true("A String" == a_string)
 230   end)
 231
 232   assert_pass("assert_equal(\"A String\", \"A String\", \"A message\") doesn't work!", function()
 233     local a_string = assert_equal("A String", "A String", "A message")
 234     assert_true("A String" == a_string)
 235   end)
 236
 237   assert_pass("assert_equal(12345, 12345) doesn't work!", function()
 238     local a_number = assert_equal(12345, 12345)
 239     assert_true(12345 == a_number)
 240   end)
 241
 242   assert_pass("assert_equal(12345, 12345, \"A message\") doesn't work!", function()
 243     local a_number = assert_equal(12345, 12345, "A message")
 244     assert_true(12345 == a_number)
 245   end)
 246
 247   assert_pass("assert_equal(nil, nil) doesn't work!", function()
 248     local a_nil = assert_equal(nil, nil)
 249     assert_true(nil == a_nil)
 250   end)
 251
 252   assert_pass("assert_equal(12345, 12345, \"A message\") doesn't work!", function()
 253     local a_nil = assert_equal(nil, nil, "A message")
 254     assert_true(nil == a_nil)
 255   end)
 256
 257   assert_pass("assert_equal(false, false) doesn't work!", function()
 258     local a_false = assert_equal(false, false)
 259     assert_true(false == a_false)
 260   end)
 261
 262   assert_pass("assert_equal(false, false, \"A message\") doesn't work!", function()
 263     local a_false = assert_equal(false, false, "A message")
 264     assert_true(false == a_false)
 265   end)
 266
 267   assert_pass("assert_equal(true, true) doesn't work!", function()
 268     local a_true = assert_equal(true, true)
 269     assert_true(true == a_true)
 270   end)
 271
 272   assert_pass("assert_equal(true, true, \"A message\") doesn't work!", function()
 273     local a_true = assert_equal(true, true, "A message")
 274     assert_true(true == a_true)
 275   end)
 276
 277   assert_error("assert_equal(\"A String\", \"Another String\") doesn't fail!", function()
 278     assert_equal("A String", "Another String")
 279   end)
 280
 281   assert_error("assert_equal(\"A String\", \"Another String\", \"A message\") doesn't fail!", function()
 282     assert_equal("A String", "Another String", "A message")
 283   end)
 284
 285   assert_error("assert_equal(123, 456) doesn't fail!", function()
 286     assert_equal(123, 456)
 287   end)
 288
 289   assert_error("assert_equal(123, 456) \"A message\") doesn't fail!", function()
 290     assert_equal(123, 456, "A message")
 291   end)
 292
 293   assert_error("assert_equal(true, false) doesn't fail!", function()
 294     assert_equal(true, false)
 295   end)
 296
 297   assert_error("assert_equal(true, false) \"A message\") doesn't fail!", function()
 298     assert_equal(true, false, "A message")
 299   end)
 300
 301   assert_error("assert_equal(true, nil) doesn't fail!", function()
 302     assert_equal(true, nil)
 303   end)
 304
 305   assert_error("assert_equal(true, nil) \"A message\") doesn't fail!", function()
 306     assert_equal(true, nil, "A message")
 307   end)
 308
 309   assert_error("assert_equal(false, true) doesn't fail!", function()
 310     assert_equal(false, true)
 311   end)
 312
 313   assert_error("assert_equal(false, true, \"A message\") doesn't fail!", function()
 314     assert_equal(false, true, "A message")
 315   end)
 316
 317   assert_error("assert_equal(false, nil) doesn't fail!", function()
 318     assert_equal(false, nil)
 319   end)
 320
 321   assert_error("assert_equal(false, nil) \"A message\") doesn't fail!", function()
 322     assert_equal(false, nil, "A message")
 323   end)
 324
 325   assert_error("assert_equal(nil, true) doesn't fail!", function()
 326     assert_equal(nil, true)
 327   end)
 328
 329   assert_error("assert_equal(nil, true) \"A message\") doesn't fail!", function()
 330     assert_equal(nil, true, "A message")
 331   end)
 332
 333   assert_error("assert_equal(nil, false) doesn't fail!", function()
 334     assert_equal(nil, false)
 335   end)
 336
 337   assert_error("assert_equal(nil, false) \"A message\") doesn't fail!", function()
 338     assert_equal(nil, false, "A message")
 339   end)
 340
 341 end
 342
 343
 344 function test_assert_not_equal()
 345
 346   assert_pass("assert_not_equal(\"A String\", \"Another String\") doesn't work!", function()
 347     local a_string = assert_not_equal("A String", "Another String")
 348     assert_true("Another String" == a_string)
 349   end)
 350
 351   assert_pass("assert_not_equal(\"A String\", \"Another String\", \"A message\") doesn't work!", function()
 352     local a_string = assert_not_equal("A String", "Another String", "A message")
 353     assert_true("Another String" == a_string)
 354   end)
 355
 356   assert_pass("assert_not_equal(123, 456) doesn't work!", function()
 357     local a_number = assert_not_equal(123, 456)
 358     assert_true(456 == a_number)
 359   end)
 360
 361   assert_pass("assert_not_equal(123, 456, \"A message\") doesn't work!", function()
 362     local a_number = assert_not_equal(123, 456, "A message")
 363     assert_true(456 == a_number)
 364   end)
 365
 366   assert_pass("assert_not_equal(true, false) doesn't work!", function()
 367     local a_false = assert_not_equal(true, false)
 368     assert_true(false == a_false)
 369   end)
 370
 371   assert_pass("assert_not_equal(true, false) \"A message\") doesn't work!", function()
 372     local a_false = assert_not_equal(true, false, "A message")
 373     assert_true(false == a_false)
 374   end)
 375
 376   assert_pass("assert_not_equal(true, nil) doesn't work!", function()
 377     local a_nil = assert_not_equal(true, nil)
 378     assert_true(nil == a_nil)
 379   end)
 380
 381   assert_pass("assert_not_equal(true, nil) \"A message\") doesn't work!", function()
 382     local a_nil = assert_not_equal(true, nil, "A message")
 383     assert_true(nil == a_nil)
 384   end)
 385
 386   assert_pass("assert_not_equal(false, true) doesn't work!", function()
 387     local a_true = assert_not_equal(false, true)
 388     assert_true(true == a_true)
 389   end)
 390
 391   assert_pass("assert_not_equal(false, true, \"A message\") doesn't work!", function()
 392     local a_true = assert_not_equal(false, true, "A message")
 393     assert_true(true == a_true)
 394   end)
 395
 396   assert_pass("assert_not_equal(false, nil) doesn't work!", function()
 397     local a_nil = assert_not_equal(false, nil)
 398     assert_true(nil == a_nil)
 399   end)
 400
 401   assert_pass("assert_not_equal(false, nil) \"A message\") doesn't work!", function()
 402     local a_nil = assert_not_equal(false, nil, "A message")
 403     assert_true(nil == a_nil)
 404   end)
 405
 406   assert_pass("assert_not_equal(nil, true) doesn't work!", function()
 407     local a_true = assert_not_equal(nil, true)
 408     assert_true(true == a_true)
 409   end)
 410
 411   assert_pass("assert_not_equal(nil, true) \"A message\") doesn't work!", function()
 412     local a_true = assert_not_equal(nil, true, "A message")
 413     assert_true(true == a_true)
 414   end)
 415
 416   assert_pass("assert_not_equal(nil, false) doesn't work!", function()
 417     local a_false = assert_not_equal(nil, false)
 418     assert_true(false == a_false)
 419   end)
 420
 421   assert_pass("assert_not_equal(nil, false) \"A message\") doesn't work!", function()
 422     local a_false = assert_not_equal(nil, false, "A message")
 423     assert_true(false == a_false)
 424   end)
 425
 426   assert_error("assert_not_equal(\"A String\", \"A String\") doesn't work!", function()
 427     assert_not_equal("A String", "A String")
 428   end)
 429
 430   assert_error("assert_not_equal(\"A String\", \"A String\", \"A message\") doesn't fail!", function()
 431     assert_not_equal("A String", "A String", "A message")
 432   end)
 433
 434   assert_error("assert_not_equal(12345, 12345) doesn't fail!", function()
 435     assert_not_equal(12345, 12345)
 436   end)
 437
 438   assert_error("assert_not_equal(12345, 12345, \"A message\") doesn't fail!", function()
 439     assert_not_equal(12345, 12345, "A message")
 440   end)
 441
 442   assert_error("assert_not_equal(nil, nil) doesn't fail!", function()
 443     assert_not_equal(nil, nil)
 444   end)
 445
 446   assert_error("assert_not_equal(nil, nil, \"A message\") doesn't fail!", function()
 447     assert_not_equal(nil, nil, "A message")
 448   end)
 449
 450   assert_error("assert_not_equal(false, false) doesn't fail!", function()
 451     assert_not_equal(false, false)
 452   end)
 453
 454   assert_error("assert_not_equal(false, false, \"A message\") doesn't fail!", function()
 455     assert_not_equal(false, false, "A message")
 456   end)
 457
 458   assert_error("assert_not_equal(true, true) doesn't fail!", function()
 459     assert_not_equal(true, true)
 460   end)
 461
 462   assert_error("assert_not_equal(true, true, \"A message\") doesn't fail!", function()
 463     assert_not_equal(true, true, "A message")
 464   end)
 465
 466 end
 467
 468
 469
 470 module( "lunit-tests.is_xyz", lunit.testcase )
 471
 472 function test_is_nil()
 473   assert_true( is_nil(nil) )
 474   assert_false( is_nil(true) )
 475   assert_false( is_nil(false) )
 476   assert_false( is_nil(a_number) )
 477   assert_false( is_nil(a_string) )
 478   assert_false( is_nil(a_table) )
 479   assert_false( is_nil(a_function) )
 480   assert_false( is_nil(a_thread) )
 481 end
 482
 483 function test_is_boolean()
 484   assert_true( is_boolean(false) )
 485   assert_true( is_boolean(true) )
 486   assert_false( is_boolean(nil) )
 487   assert_false( is_boolean(a_number) )
 488   assert_false( is_boolean(a_string) )
 489   assert_false( is_boolean(a_table) )
 490   assert_false( is_boolean(a_function) )
 491   assert_false( is_boolean(a_thread) )
 492 end
 493
 494 function test_is_number()
 495   assert_true( is_number(a_number) )
 496   assert_false( is_number(nil) )
 497   assert_false( is_number(true) )
 498   assert_false( is_number(false) )
 499   assert_false( is_number(a_string) )
 500   assert_false( is_number(a_table) )
 501   assert_false( is_number(a_function) )
 502   assert_false( is_number(a_thread) )
 503 end
 504
 505 function test_is_string()
 506   assert_true( is_string(a_string) )
 507   assert_false( is_string(nil) )
 508   assert_false( is_string(true) )
 509   assert_false( is_string(false) )
 510   assert_false( is_string(a_number) )
 511   assert_false( is_string(a_table) )
 512   assert_false( is_string(a_function) )
 513   assert_false( is_string(a_thread) )
 514 end
 515
 516 function test_is_table()
 517   assert_true( is_table(a_table) )
 518   assert_false( is_table(nil) )
 519   assert_false( is_table(true) )
 520   assert_false( is_table(false) )
 521   assert_false( is_table(a_number) )
 522   assert_false( is_table(a_string) )
 523   assert_false( is_table(a_function) )
 524   assert_false( is_table(a_thread) )
 525 end
 526
 527 function test_is_function()
 528   assert_true( is_function(a_function) )
 529   assert_false( is_function(nil) )
 530   assert_false( is_function(true) )
 531   assert_false( is_function(false) )
 532   assert_false( is_function(a_number) )
 533   assert_false( is_function(a_string) )
 534   assert_false( is_function(a_table) )
 535   assert_false( is_function(a_thread) )
 536 end
 537
 538 function test_is_thread()
 539   assert_true( is_thread(a_thread) )
 540   assert_false( is_thread(nil) )
 541   assert_false( is_thread(true) )
 542   assert_false( is_thread(false) )
 543   assert_false( is_thread(a_number) )
 544   assert_false( is_thread(a_string) )
 545   assert_false( is_thread(a_table) )
 546   assert_false( is_thread(a_function) )
 547 end
 548
 549
 550
 551 module( "lunit-tests.assert_not_xyz", lunit.testcase )
 552
 553 function test_assert_not_nil()
 554   assert_not_nil( true )
 555   assert_not_nil( false )
 556   assert_not_nil( a_number )
 557   assert_not_nil( a_string )
 558   assert_not_nil( a_table )
 559   assert_not_nil( a_function )
 560   assert_not_nil( a_thread )
 561
 562   assert_not_nil( true, "A message")
 563   assert_not_nil( false, "A message")
 564   assert_not_nil( a_number, "A message")
 565   assert_not_nil( a_string, "A message")
 566   assert_not_nil( a_table, "A message")
 567   assert_not_nil( a_function, "A message")
 568   assert_not_nil( a_thread, "A message")
 569
 570   assert_error(function() assert_not_nil(nil) end)
 571   assert_error(function() assert_not_nil(nil, "A message") end)
 572 end
 573
 574 function test_assert_not_boolean()
 575   assert_not_boolean( nil )
 576   assert_not_boolean( a_number )
 577   assert_not_boolean( a_string )
 578   assert_not_boolean( a_table )
 579   assert_not_boolean( a_function )
 580   assert_not_boolean( a_thread )
 581
 582   assert_not_boolean( nil, "A message")
 583   assert_not_boolean( a_number, "A message")
 584   assert_not_boolean( a_string, "A message")
 585   assert_not_boolean( a_table, "A message")
 586   assert_not_boolean( a_function, "A message")
 587   assert_not_boolean( a_thread, "A message")
 588
 589   assert_error(function() assert_not_boolean(true) end)
 590   assert_error(function() assert_not_boolean(true, "A message") end)
 591   assert_error(function() assert_not_boolean(false) end)
 592   assert_error(function() assert_not_boolean(false, "A message") end)
 593 end
 594
 595 function test_assert_not_number()
 596   assert_not_number( nil )
 597   assert_not_number( true )
 598   assert_not_number( false )
 599   assert_not_number( a_string )
 600   assert_not_number( a_table )
 601   assert_not_number( a_function )
 602   assert_not_number( a_thread )
 603
 604   assert_not_number( nil, "A message")
 605   assert_not_number( true, "A message")
 606   assert_not_number( false, "A message")
 607   assert_not_number( a_string, "A message")
 608   assert_not_number( a_table, "A message")
 609   assert_not_number( a_function, "A message")
 610   assert_not_number( a_thread, "A message")
 611
 612   assert_error(function() assert_not_number(a_number) end)
 613   assert_error(function() assert_not_number(a_number, "A message") end)
 614 end
 615
 616 function test_assert_not_string()
 617   assert_not_string( nil )
 618   assert_not_string( true )
 619   assert_not_string( false )
 620   assert_not_string( a_number )
 621   assert_not_string( a_table )
 622   assert_not_string( a_function )
 623   assert_not_string( a_thread )
 624
 625   assert_not_string( nil, "A message")
 626   assert_not_string( true, "A message")
 627   assert_not_string( false, "A message")
 628   assert_not_string( a_number, "A message")
 629   assert_not_string( a_table, "A message")
 630   assert_not_string( a_function, "A message")
 631   assert_not_string( a_thread, "A message")
 632
 633   assert_error(function() assert_not_string(a_string) end)
 634   assert_error(function() assert_not_string(a_string, "A message") end)
 635 end
 636
 637 function test_assert_not_table()
 638   assert_not_table( nil )
 639   assert_not_table( true )
 640   assert_not_table( false )
 641   assert_not_table( a_number )
 642   assert_not_table( a_string )
 643   assert_not_table( a_function )
 644   assert_not_table( a_thread )
 645
 646   assert_not_table( nil, "A message")
 647   assert_not_table( true, "A message")
 648   assert_not_table( false, "A message")
 649   assert_not_table( a_number, "A message")
 650   assert_not_table( a_string, "A message")
 651   assert_not_table( a_function, "A message")
 652   assert_not_table( a_thread, "A message")
 653
 654   assert_error(function() assert_not_table(a_table) end)
 655   assert_error(function() assert_not_table(a_table, "A message") end)
 656 end
 657
 658 function test_assert_not_function()
 659   assert_not_function( nil )
 660   assert_not_function( true )
 661   assert_not_function( false )
 662   assert_not_function( a_number )
 663   assert_not_function( a_string )
 664   assert_not_function( a_table )
 665   assert_not_function( a_thread )
 666
 667   assert_not_function( nil, "A message")
 668   assert_not_function( true, "A message")
 669   assert_not_function( false, "A message")
 670   assert_not_function( a_number, "A message")
 671   assert_not_function( a_string, "A message")
 672   assert_not_function( a_table, "A message")
 673   assert_not_function( a_thread, "A message")
 674
 675   assert_error(function() assert_not_function(a_function) end)
 676   assert_error(function() assert_not_function(a_function, "A message") end)
 677 end
 678
 679 function test_assert_not_thread()
 680   assert_not_thread( nil )
 681   assert_not_thread( true )
 682   assert_not_thread( false )
 683   assert_not_thread( a_number )
 684   assert_not_thread( a_string )
 685   assert_not_thread( a_table )
 686   assert_not_thread( a_function )
 687
 688   assert_not_thread( nil, "A message")
 689   assert_not_thread( true, "A message")
 690   assert_not_thread( false, "A message")
 691   assert_not_thread( a_number, "A message")
 692   assert_not_thread( a_string, "A message")
 693   assert_not_thread( a_table, "A message")
 694   assert_not_thread( a_function, "A message")
 695
 696   assert_error(function() assert_not_thread(a_thread) end)
 697   assert_error(function() assert_not_thread(a_thread, "A message") end)
 698 end
 699
 700
 701
 702 module( "lunit-tests.assert_xyz", lunit.testcase )
 703
 704 function test_assert_nil()
 705   assert_nil( nil )
 706   assert_nil( nil, "A message" )
 707
 708   assert_error( function() assert_nil( true ) end)
 709   assert_error( function() assert_nil( false ) end)
 710   assert_error( function() assert_nil( a_number ) end)
 711   assert_error( function() assert_nil( a_string ) end)
 712   assert_error( function() assert_nil( a_table ) end)
 713   assert_error( function() assert_nil( a_function ) end)
 714   assert_error( function() assert_nil( a_thread ) end)
 715
 716   assert_error( function() assert_nil( true, "A message" ) end)
 717   assert_error( function() assert_nil( false, "A message" ) end)
 718   assert_error( function() assert_nil( a_number, "A message" ) end)
 719   assert_error( function() assert_nil( a_string, "A message" ) end)
 720   assert_error( function() assert_nil( a_table, "A message" ) end)
 721   assert_error( function() assert_nil( a_function, "A message" ) end)
 722   assert_error( function() assert_nil( a_thread, "A message" ) end)
 723 end
 724
 725 function test_assert_boolean()
 726   assert_boolean( true )
 727   assert_boolean( false )
 728   assert_boolean( true, "A message" )
 729   assert_boolean( false, "A message" )
 730
 731   assert_error( function() assert_boolean( nil ) end)
 732   assert_error( function() assert_boolean( a_number ) end)
 733   assert_error( function() assert_boolean( a_string ) end)
 734   assert_error( function() assert_boolean( a_table ) end)
 735   assert_error( function() assert_boolean( a_function ) end)
 736   assert_error( function() assert_boolean( a_thread ) end)
 737
 738   assert_error( function() assert_boolean( nil, "A message" ) end)
 739   assert_error( function() assert_boolean( a_number, "A message" ) end)
 740   assert_error( function() assert_boolean( a_string, "A message" ) end)
 741   assert_error( function() assert_boolean( a_table, "A message" ) end)
 742   assert_error( function() assert_boolean( a_function, "A message" ) end)
 743   assert_error( function() assert_boolean( a_thread, "A message" ) end)
 744 end
 745
 746 function test_assert_number()
 747   assert_number( a_number )
 748   assert_number( a_number, "A message" )
 749
 750   assert_error( function() assert_number( nil ) end)
 751   assert_error( function() assert_number( true ) end)
 752   assert_error( function() assert_number( false ) end)
 753   assert_error( function() assert_number( a_string ) end)
 754   assert_error( function() assert_number( a_table ) end)
 755   assert_error( function() assert_number( a_function ) end)
 756   assert_error( function() assert_number( a_thread ) end)
 757
 758   assert_error( function() assert_number( nil, "A message" ) end)
 759   assert_error( function() assert_number( true, "A message" ) end)
 760   assert_error( function() assert_number( false, "A message" ) end)
 761   assert_error( function() assert_number( a_string, "A message" ) end)
 762   assert_error( function() assert_number( a_table, "A message" ) end)
 763   assert_error( function() assert_number( a_function, "A message" ) end)
 764   assert_error( function() assert_number( a_thread, "A message" ) end)
 765 end
 766
 767 function test_assert_string()
 768   assert_string( a_string )
 769   assert_string( a_string, "A message" )
 770
 771   assert_error( function() assert_string( nil ) end)
 772   assert_error( function() assert_string( true ) end)
 773   assert_error( function() assert_string( false ) end)
 774   assert_error( function() assert_string( a_number ) end)
 775   assert_error( function() assert_string( a_table ) end)
 776   assert_error( function() assert_string( a_function ) end)
 777   assert_error( function() assert_string( a_thread ) end)
 778
 779   assert_error( function() assert_string( nil, "A message" ) end)
 780   assert_error( function() assert_string( true, "A message" ) end)
 781   assert_error( function() assert_string( false, "A message" ) end)
 782   assert_error( function() assert_string( a_number, "A message" ) end)
 783   assert_error( function() assert_string( a_table, "A message" ) end)
 784   assert_error( function() assert_string( a_function, "A message" ) end)
 785   assert_error( function() assert_string( a_thread, "A message" ) end)
 786 end
 787
 788 function test_assert_table()
 789   assert_table( a_table )
 790   assert_table( a_table, "A message" )
 791
 792   assert_error( function() assert_table( nil ) end)
 793   assert_error( function() assert_table( true ) end)
 794   assert_error( function() assert_table( false ) end)
 795   assert_error( function() assert_table( a_number ) end)
 796   assert_error( function() assert_table( a_string ) end)
 797   assert_error( function() assert_table( a_function ) end)
 798   assert_error( function() assert_table( a_thread ) end)
 799
 800   assert_error( function() assert_table( nil, "A message" ) end)
 801   assert_error( function() assert_table( true, "A message" ) end)
 802   assert_error( function() assert_table( false, "A message" ) end)
 803   assert_error( function() assert_table( a_number, "A message" ) end)
 804   assert_error( function() assert_table( a_string, "A message" ) end)
 805   assert_error( function() assert_table( a_function, "A message" ) end)
 806   assert_error( function() assert_table( a_thread, "A message" ) end)
 807 end
 808
 809 function test_assert_function()
 810   assert_function( a_function )
 811   assert_function( a_function, "A message" )
 812
 813   assert_error( function() assert_function( nil ) end)
 814   assert_error( function() assert_function( true ) end)
 815   assert_error( function() assert_function( false ) end)
 816   assert_error( function() assert_function( a_number ) end)
 817   assert_error( function() assert_function( a_string ) end)
 818   assert_error( function() assert_function( a_table ) end)
 819   assert_error( function() assert_function( a_thread ) end)
 820
 821   assert_error( function() assert_function( nil, "A message" ) end)
 822   assert_error( function() assert_function( true, "A message" ) end)
 823   assert_error( function() assert_function( false, "A message" ) end)
 824   assert_error( function() assert_function( a_number, "A message" ) end)
 825   assert_error( function() assert_function( a_string, "A message" ) end)
 826   assert_error( function() assert_function( a_table, "A message" ) end)
 827   assert_error( function() assert_function( a_thread, "A message" ) end)
 828 end
 829
 830 function test_assert_thread()
 831   assert_thread( a_thread )
 832   assert_thread( a_thread, "A message" )
 833
 834   assert_error( function() assert_thread( nil ) end)
 835   assert_error( function() assert_thread( true ) end)
 836   assert_error( function() assert_thread( false ) end)
 837   assert_error( function() assert_thread( a_number ) end)
 838   assert_error( function() assert_thread( a_string ) end)
 839   assert_error( function() assert_thread( a_table ) end)
 840   assert_error( function() assert_thread( a_function ) end)
 841
 842   assert_error( function() assert_thread( nil, "A message" ) end)
 843   assert_error( function() assert_thread( true, "A message" ) end)
 844   assert_error( function() assert_thread( false, "A message" ) end)
 845   assert_error( function() assert_thread( a_number, "A message" ) end)
 846   assert_error( function() assert_thread( a_string, "A message" ) end)
 847   assert_error( function() assert_thread( a_table, "A message" ) end)
 848   assert_error( function() assert_thread( a_function, "A message" ) end)
 849 end
 850
 851
 852
 853
 854 module( "lunit-tests.match", lunit.testcase )
 855
 856 function test_assert_match()
 857
 858   assert_pass("assert_match(\"^Hello\", \"Hello World\") doesn't work!", function()
 859     local a_string = assert_match("^Hello", "Hello World")
 860     assert_equal("Hello World", a_string)
 861   end)
 862
 863   assert_pass("assert_match(\"^Hello\", \"Hello World\", \"A Message\") doesn't work!", function()
 864     local a_string = assert_match("^Hello", "Hello World", "A message")
 865     assert_equal("Hello World", a_string)
 866   end)
 867
 868   assert_pass("assert_match(\"World$\", \"Hello World\") doesn't work!", function()
 869     local a_string = assert_match("World$", "Hello World")
 870     assert_equal("Hello World", a_string)
 871   end)
 872
 873   assert_pass("assert_match(\"World$\", \"Hello World\", \"A Message\") doesn't work!", function()
 874     local a_string = assert_match("World$", "Hello World", "A message")
 875     assert_equal("Hello World", a_string)
 876   end)
 877
 878   assert_error("assert_match(\"Hello$\", \"Hello World\") doesn't fail!", function()
 879     assert_match("Hello$", "Hello World")
 880   end)
 881
 882   assert_error("assert_match(\"Hello$\", \"Hello World\", \"A Message\") doesn't fail!", function()
 883     assert_match("Hello$", "Hello World", "A message")
 884   end)
 885
 886   assert_error("assert_match(\"^World\", \"Hello World\") doesn't fail!", function()
 887     assert_match("^World", "Hello World")
 888   end)
 889
 890   assert_error("assert_match(\"^World\", \"Hello World\", \"A Message\") doesn't fail!", function()
 891     assert_match("^World", "Hello World", "A message")
 892   end)
 893
 894   assert_error("assert_match(nil, \"Hello World\") doesn't fail!", function()
 895     assert_match(nil, "Hello World")
 896   end)
 897
 898   assert_error("assert_match(nil, \"Hello World\", \"A Message\") doesn't fail!", function()
 899     assert_match(nil, "Hello World", "A message")
 900   end)
 901
 902   assert_error("assert_match(\"^World\", nil) doesn't fail!", function()
 903     assert_match("^World", nil)
 904   end)
 905
 906   assert_error("assert_match(\"^World\", nil, \"A Message\") doesn't fail!", function()
 907     assert_match("^World", nil, "A message")
 908   end)
 909
 910 end
 911
 912 function test_assert_not_match()
 913   assert_pass("assert_not_match(\"Hello$\", \"Hello World\") doesn't work!", function()
 914     local a_string = assert_not_match("Hello$", "Hello World")
 915     assert_equal("Hello World", a_string)
 916   end)
 917
 918   assert_pass("assert_not_match(\"Hello$\", \"Hello World\", \"A Message\") doesn't work!", function()
 919     local a_string = assert_not_match("Hello$", "Hello World", "A message")
 920     assert_equal("Hello World", a_string)
 921   end)
 922
 923   assert_pass("assert_not_match(\"^World\", \"Hello World\") doesn't work!", function()
 924     local a_string = assert_not_match("^World", "Hello World")
 925     assert_equal("Hello World", a_string)
 926   end)
 927
 928   assert_pass("assert_not_match(\"^World\", \"Hello World\", \"A Message\") doesn't work!", function()
 929     local a_string = assert_not_match("^World", "Hello World", "A message")
 930     assert_equal("Hello World", a_string)
 931   end)
 932
 933   assert_error("assert_not_match(\"^Hello\", \"Hello World\") doesn't fail!", function()
 934     assert_not_match("^Hello", "Hello World")
 935   end)
 936
 937   assert_error("assert_not_match(\"^Hello\", \"Hello World\", \"A Message\") doesn't fail!", function()
 938     assert_not_match("^Hello", "Hello World", "A message")
 939   end)
 940
 941   assert_error("assert_not_match(\"World$\", \"Hello World\") doesn't fail!", function()
 942     assert_not_match("World$", "Hello World")
 943   end)
 944
 945   assert_error("assert_not_match(\"World$\", \"Hello World\", \"A Message\") doesn't fail!", function()
 946     assert_not_match("World$", "Hello World", "A message")
 947   end)
 948
 949   assert_error("assert_not_match(nil, \"Hello World\") doesn't fail!", function()
 950     assert_not_match(nil, "Hello World")
 951   end)
 952
 953   assert_error("assert_not_match(nil, \"Hello World\", \"A Message\") doesn't fail!", function()
 954     assert_not_match(nil, "Hello World", "A message")
 955   end)
 956
 957   assert_error("assert_not_match(\"^World\", nil) doesn't fail!", function()
 958     assert_not_match("^World", nil)
 959   end)
 960
 961   assert_error("assert_not_match(\"^World\", nil, \"A Message\") doesn't fail!", function()
 962     assert_not_match("^World", nil, "A message")
 963   end)
 964
 965 end
 966
 967
 968
 969 --
 970 -- Check if setup and teardown is called.
 971 --
 972 module( "lunit-tests.setup-teardown", lunit.testcase )
 973
 974 local setup_called = 0
 975 local teardown_called = 0
 976 local helper_called = 0
 977
 978 function setup()
 979   setup_called = setup_called + 1
 980 end
 981
 982 function Teardown()
 983   teardown_called = teardown_called + 1
 984 end
 985
 986 local function helper()
 987   helper_called = helper_called + 1
 988   assert(setup_called == helper_called, "setup() not called")
 989   assert(teardown_called == helper_called - 1, "teardown() not called")
 990 end
 991
 992 function test1()
 993   helper()
 994 end
 995
 996 function test2()
 997   helper()
 998 end
 999
1000 function test3()
1001   helper()
1002 end