contrib/lutok/state_test.cpp

   1 // Copyright 2011 Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 // * Redistributions of source code must retain the above copyright
   9 //   notice, this list of conditions and the following disclaimer.
  10 // * Redistributions in binary form must reproduce the above copyright
  11 //   notice, this list of conditions and the following disclaimer in the
  12 //   documentation and/or other materials provided with the distribution.
  13 // * Neither the name of Google Inc. nor the names of its contributors
  14 //   may be used to endorse or promote products derived from this software
  15 //   without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 #include "state.ipp"
  30
  31 #include <cstring>
  32 #include <fstream>
  33 #include <iostream>
  34 #include <stdexcept>
  35
  36 #include <atf-c++.hpp>
  37 #include <lua.hpp>
  38
  39 #include "c_gate.hpp"
  40 #include "exceptions.hpp"
  41 #include "test_utils.hpp"
  42
  43
  44 // A note about the lutok::state tests.
  45 //
  46 // The methods of lutok::state are, in general, thin wrappers around the
  47 // corresponding Lua C API methods.  The tests below are simple unit tests that
  48 // ensure that these functions just delegate the calls to the Lua library.  We
  49 // do not intend to test the validity of the methods themselves (that's the
  50 // job of the Lua authors).  That said, we test those conditions we rely on,
  51 // such as the reporting of errors and the default values to the API.
  52 //
  53 // Lastly, for every test case that stresses a single lutok::state method, we
  54 // only call that method directly.  All other Lua state manipulation operations
  55 // are performed by means of direct calls to the Lua C API.  This is to ensure
  56 // that the wrapped methods are really talking to Lua.
  57
  58
  59 namespace {
  60
  61
  62 /// Checks if a symbol is available.
  63 ///
  64 /// \param state The Lua state.
  65 /// \param symbol The symbol to check for.
  66 ///
  67 /// \return True if the symbol is defined, false otherwise.
  68 static bool
  69 is_available(lutok::state& state, const char* symbol)
  70 {
  71     luaL_loadstring(raw(state), (std::string("return ") + symbol).c_str());
  72     const bool ok = (lua_pcall(raw(state), 0, 1, 0) == 0 &&
  73                      !lua_isnil(raw(state), -1));
  74     lua_pop(raw(state), 1);
  75     std::cout << "Symbol " << symbol << (ok ? " found\n" : " not found\n");
  76     return ok;
  77 }
  78
  79
  80 /// Checks that no modules are present or that only one has been loaded.
  81 ///
  82 /// \post The test case terminates if there is any module present when expected
  83 /// is empty or if there two modules loaded when expected is defined.
  84 ///
  85 /// \param state The Lua state.
  86 /// \param expected The module to expect.  Empty if no modules are allowed.
  87 static void
  88 check_modules(lutok::state& state, const std::string& expected)
  89 {
  90     std::cout << "Checking loaded modules" <<
  91         (expected.empty() ? "" : (" (" + expected + " expected)")) << "\n";
  92     ATF_REQUIRE(!((expected == "base") ^ (is_available(state, "assert"))));
  93     ATF_REQUIRE(!((expected == "string") ^
  94                   (is_available(state, "string.byte"))));
  95     ATF_REQUIRE(!((expected == "table") ^
  96                   (is_available(state, "table.concat"))));
  97 }
  98
  99
 100 /// A C closure that returns its two integral upvalues.
 101 ///
 102 /// \post stack(-2) contains the first upvalue.
 103 /// \post stack(-1) contains the second upvalue.
 104 ///
 105 /// \param raw_state The raw Lua state.
 106 ///
 107 /// \return The number of result values, i.e. 2.
 108 static int
 109 c_get_upvalues(lua_State* raw_state)
 110 {
 111     lutok::state state = lutok::state_c_gate::connect(raw_state);
 112     const int i1 = lua_tointeger(raw_state, state.upvalue_index(1));
 113     const int i2 = lua_tointeger(raw_state, state.upvalue_index(2));
 114     lua_pushinteger(raw_state, i1);
 115     lua_pushinteger(raw_state, i2);
 116     return 2;
 117 }
 118
 119
 120 /// A custom C++ multiply function with one of its factors on its closure.
 121 ///
 122 /// \pre stack(-1) contains the second factor.
 123 /// \post stack(-1) contains the product of the two input factors.
 124 ///
 125 /// \param state The Lua state.
 126 ///
 127 /// \return The number of result values, i.e. 1.
 128 static int
 129 cxx_multiply_closure(lutok::state& state)
 130 {
 131     const int f1 = lua_tointeger(raw(state), lua_upvalueindex(1));
 132     const int f2 = lua_tointeger(raw(state), -1);
 133     lua_pushinteger(raw(state), f1 * f2);
 134     return 1;
 135 }
 136
 137
 138 /// A custom C++ integral division function for Lua.
 139 ///
 140 /// \pre stack(-2) contains the dividend.
 141 /// \pre stack(-1) contains the divisor.
 142 /// \post stack(-2) contains the quotient of the division.
 143 /// \post stack(-1) contains the remainder of the division.
 144 ///
 145 /// \param state The Lua state.
 146 ///
 147 /// \return The number of result values, i.e. 1.
 148 ///
 149 /// \throw std::runtime_error If the divisor is zero.
 150 /// \throw std::string If the dividend or the divisor are negative.  This is an
 151 ///     exception not derived from std::exception on purpose to ensure that the
 152 ///     C++ wrapping correctly captures any exception regardless of its type.
 153 static int
 154 cxx_divide(lutok::state& state)
 155 {
 156     const int dividend = state.to_integer(-2);
 157     const int divisor = state.to_integer(-1);
 158     if (divisor == 0)
 159         throw std::runtime_error("Divisor is 0");
 160     if (dividend < 0 || divisor < 0)
 161         throw std::string("Cannot divide negative numbers");
 162     state.push_integer(dividend / divisor);
 163     state.push_integer(dividend % divisor);
 164     return 2;
 165 }
 166
 167
 168 /// A Lua function that raises a very long error message.
 169 ///
 170 /// \pre stack(-1) contains the length of the message to construct.
 171 ///
 172 /// \param state The Lua state.
 173 ///
 174 /// \return Never returns.
 175 ///
 176 /// \throw std::runtime_error Unconditionally, with an error message formed by
 177 ///     the repetition of 'A' as many times as requested.
 178 static int
 179 raise_long_error(lutok::state& state)
 180 {
 181     const int length = state.to_integer(-1);
 182     throw std::runtime_error(std::string(length, 'A').c_str());
 183 }
 184
 185
 186 }  // anonymous namespace
 187
 188
 189 ATF_TEST_CASE_WITHOUT_HEAD(close);
 190 ATF_TEST_CASE_BODY(close)
 191 {
 192     lutok::state state;
 193     state.close();
 194     // The destructor for state will run now.  If it does a second close, we may
 195     // crash, so let's see if we don't.
 196 }
 197
 198
 199 ATF_TEST_CASE_WITHOUT_HEAD(get_global__ok);
 200 ATF_TEST_CASE_BODY(get_global__ok)
 201 {
 202     lutok::state state;
 203     ATF_REQUIRE(luaL_dostring(raw(state), "test_variable = 3") == 0);
 204     state.get_global("test_variable");
 205     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 206     lua_pop(raw(state), 1);
 207 }
 208
 209
 210 ATF_TEST_CASE_WITHOUT_HEAD(get_global__undefined);
 211 ATF_TEST_CASE_BODY(get_global__undefined)
 212 {
 213     lutok::state state;
 214     state.get_global("test_variable");
 215     ATF_REQUIRE(lua_isnil(raw(state), -1));
 216     lua_pop(raw(state), 1);
 217 }
 218
 219
 220 ATF_TEST_CASE_WITHOUT_HEAD(get_global_table);
 221 ATF_TEST_CASE_BODY(get_global_table)
 222 {
 223     lutok::state state;
 224     ATF_REQUIRE(luaL_dostring(raw(state), "global_variable = 'hello'") == 0);
 225     state.get_global_table();
 226     lua_pushstring(raw(state), "global_variable");
 227     lua_gettable(raw(state), -2);
 228     ATF_REQUIRE(lua_isstring(raw(state), -1));
 229     ATF_REQUIRE(std::strcmp("hello", lua_tostring(raw(state), -1)) == 0);
 230     lua_pop(raw(state), 2);
 231 }
 232
 233
 234 ATF_TEST_CASE_WITHOUT_HEAD(get_metafield__ok);
 235 ATF_TEST_CASE_BODY(get_metafield__ok)
 236 {
 237     lutok::state state;
 238     luaL_openlibs(raw(state));
 239     ATF_REQUIRE(luaL_dostring(raw(state), "meta = { foo = 567 }; "
 240                               "t = {}; setmetatable(t, meta)") == 0);
 241     lua_getglobal(raw(state), "t");
 242     ATF_REQUIRE(state.get_metafield(-1, "foo"));
 243     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 244     ATF_REQUIRE_EQ(567, lua_tointeger(raw(state), -1));
 245     lua_pop(raw(state), 2);
 246 }
 247
 248
 249 ATF_TEST_CASE_WITHOUT_HEAD(get_metafield__undefined);
 250 ATF_TEST_CASE_BODY(get_metafield__undefined)
 251 {
 252     lutok::state state;
 253     luaL_openlibs(raw(state));
 254     ATF_REQUIRE(luaL_dostring(raw(state), "meta = { foo = 567 }; "
 255                               "t = {}; setmetatable(t, meta)") == 0);
 256     lua_getglobal(raw(state), "t");
 257     ATF_REQUIRE(!state.get_metafield(-1, "bar"));
 258     lua_pop(raw(state), 1);
 259 }
 260
 261
 262 ATF_TEST_CASE_WITHOUT_HEAD(get_metatable__ok);
 263 ATF_TEST_CASE_BODY(get_metatable__ok)
 264 {
 265     lutok::state state;
 266     luaL_openlibs(raw(state));
 267     ATF_REQUIRE(luaL_dostring(raw(state), "meta = { foo = 567 }; "
 268                               "t = {}; setmetatable(t, meta)") == 0);
 269     lua_getglobal(raw(state), "t");
 270     lua_pushinteger(raw(state), 5555);
 271     ATF_REQUIRE(state.get_metatable(-2));
 272     ATF_REQUIRE(lua_istable(raw(state), -1));
 273     lua_pushstring(raw(state), "foo");
 274     lua_gettable(raw(state), -2);
 275     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 276     ATF_REQUIRE_EQ(567, lua_tointeger(raw(state), -1));
 277     lua_pop(raw(state), 4);
 278 }
 279
 280
 281 ATF_TEST_CASE_WITHOUT_HEAD(get_metatable__undefined);
 282 ATF_TEST_CASE_BODY(get_metatable__undefined)
 283 {
 284     lutok::state state;
 285     ATF_REQUIRE(luaL_dostring(raw(state), "t = {}") == 0);
 286     lua_getglobal(raw(state), "t");
 287     ATF_REQUIRE(!state.get_metatable(-1));
 288     lua_pop(raw(state), 1);
 289 }
 290
 291
 292 ATF_TEST_CASE_WITHOUT_HEAD(get_table__ok);
 293 ATF_TEST_CASE_BODY(get_table__ok)
 294 {
 295     lutok::state state;
 296     ATF_REQUIRE(luaL_dostring(raw(state), "t = { a = 1, bar = 234 }") == 0);
 297     lua_getglobal(raw(state), "t");
 298     lua_pushstring(raw(state), "bar");
 299     state.get_table(-2);
 300     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 301     ATF_REQUIRE_EQ(234, lua_tointeger(raw(state), -1));
 302     lua_pop(raw(state), 2);
 303 }
 304
 305
 306 ATF_TEST_CASE_WITHOUT_HEAD(get_table__nil);
 307 ATF_TEST_CASE_BODY(get_table__nil)
 308 {
 309     lutok::state state;
 310     lua_pushnil(raw(state));
 311     lua_pushinteger(raw(state), 1);
 312     REQUIRE_API_ERROR("lua_gettable", state.get_table(-2));
 313     ATF_REQUIRE_EQ(2, lua_gettop(raw(state)));
 314     lua_pop(raw(state), 2);
 315 }
 316
 317
 318 ATF_TEST_CASE_WITHOUT_HEAD(get_table__unknown_index);
 319 ATF_TEST_CASE_BODY(get_table__unknown_index)
 320 {
 321     lutok::state state;
 322     ATF_REQUIRE(luaL_dostring(raw(state),
 323                               "the_table = { foo = 1, bar = 2 }") == 0);
 324     lua_getglobal(raw(state), "the_table");
 325     lua_pushstring(raw(state), "baz");
 326     state.get_table(-2);
 327     ATF_REQUIRE(lua_isnil(raw(state), -1));
 328     lua_pop(raw(state), 2);
 329 }
 330
 331
 332 ATF_TEST_CASE_WITHOUT_HEAD(get_top);
 333 ATF_TEST_CASE_BODY(get_top)
 334 {
 335     lutok::state state;
 336     ATF_REQUIRE_EQ(0, state.get_top());
 337     lua_pushinteger(raw(state), 3);
 338     ATF_REQUIRE_EQ(1, state.get_top());
 339     lua_pushinteger(raw(state), 3);
 340     ATF_REQUIRE_EQ(2, state.get_top());
 341     lua_pop(raw(state), 2);
 342 }
 343
 344
 345 ATF_TEST_CASE_WITHOUT_HEAD(insert);
 346 ATF_TEST_CASE_BODY(insert)
 347 {
 348     lutok::state state;
 349     lua_pushinteger(raw(state), 1);
 350     lua_pushinteger(raw(state), 2);
 351     lua_pushinteger(raw(state), 3);
 352     lua_pushinteger(raw(state), 4);
 353     state.insert(-3);
 354     ATF_REQUIRE_EQ(3, lua_tointeger(raw(state), -1));
 355     ATF_REQUIRE_EQ(2, lua_tointeger(raw(state), -2));
 356     ATF_REQUIRE_EQ(4, lua_tointeger(raw(state), -3));
 357     ATF_REQUIRE_EQ(1, lua_tointeger(raw(state), -4));
 358     lua_pop(raw(state), 4);
 359 }
 360
 361
 362 ATF_TEST_CASE_WITHOUT_HEAD(is_boolean__empty);
 363 ATF_TEST_CASE_BODY(is_boolean__empty)
 364 {
 365     lutok::state state;
 366     ATF_REQUIRE(!state.is_boolean(-1));
 367 }
 368
 369
 370 ATF_TEST_CASE_WITHOUT_HEAD(is_boolean__ok);
 371 ATF_TEST_CASE_BODY(is_boolean__ok)
 372 {
 373     lutok::state state;
 374     lua_pushboolean(raw(state), 1);
 375     ATF_REQUIRE(state.is_boolean(-1));
 376     lua_pushinteger(raw(state), 5);
 377     ATF_REQUIRE(!state.is_boolean(-1));
 378     ATF_REQUIRE(state.is_boolean(-2));
 379     lua_pop(raw(state), 2);
 380 }
 381
 382
 383 ATF_TEST_CASE_WITHOUT_HEAD(is_function__empty);
 384 ATF_TEST_CASE_BODY(is_function__empty)
 385 {
 386     lutok::state state;
 387     ATF_REQUIRE(!state.is_function(-1));
 388 }
 389
 390
 391 ATF_TEST_CASE_WITHOUT_HEAD(is_function__ok);
 392 ATF_TEST_CASE_BODY(is_function__ok)
 393 {
 394     lutok::state state;
 395     luaL_dostring(raw(state), "function my_func(a, b) return a + b; end");
 396
 397     lua_getglobal(raw(state), "my_func");
 398     ATF_REQUIRE(state.is_function(-1));
 399     lua_pushinteger(raw(state), 5);
 400     ATF_REQUIRE(!state.is_function(-1));
 401     ATF_REQUIRE(state.is_function(-2));
 402     lua_pop(raw(state), 2);
 403 }
 404
 405
 406 ATF_TEST_CASE_WITHOUT_HEAD(is_nil__empty);
 407 ATF_TEST_CASE_BODY(is_nil__empty)
 408 {
 409     lutok::state state;
 410     ATF_REQUIRE(state.is_nil(-1));
 411 }
 412
 413
 414 ATF_TEST_CASE_WITHOUT_HEAD(is_nil__ok);
 415 ATF_TEST_CASE_BODY(is_nil__ok)
 416 {
 417     lutok::state state;
 418     lua_pushnil(raw(state));
 419     ATF_REQUIRE(state.is_nil(-1));
 420     lua_pushinteger(raw(state), 5);
 421     ATF_REQUIRE(!state.is_nil(-1));
 422     ATF_REQUIRE(state.is_nil(-2));
 423     lua_pop(raw(state), 2);
 424 }
 425
 426
 427 ATF_TEST_CASE_WITHOUT_HEAD(is_number__empty);
 428 ATF_TEST_CASE_BODY(is_number__empty)
 429 {
 430     lutok::state state;
 431     ATF_REQUIRE(!state.is_number(-1));
 432 }
 433
 434
 435 ATF_TEST_CASE_WITHOUT_HEAD(is_number__ok);
 436 ATF_TEST_CASE_BODY(is_number__ok)
 437 {
 438     lutok::state state;
 439     lua_pushnil(raw(state));
 440     ATF_REQUIRE(!state.is_number(-1));
 441     lua_pushinteger(raw(state), 5);
 442     ATF_REQUIRE(state.is_number(-1));
 443     ATF_REQUIRE(!state.is_number(-2));
 444     lua_pop(raw(state), 2);
 445 }
 446
 447
 448 ATF_TEST_CASE_WITHOUT_HEAD(is_string__empty);
 449 ATF_TEST_CASE_BODY(is_string__empty)
 450 {
 451     lutok::state state;
 452     ATF_REQUIRE(!state.is_string(-1));
 453 }
 454
 455
 456 ATF_TEST_CASE_WITHOUT_HEAD(is_string__ok);
 457 ATF_TEST_CASE_BODY(is_string__ok)
 458 {
 459     lutok::state state;
 460     lua_pushinteger(raw(state), 3);
 461     ATF_REQUIRE(state.is_string(-1));
 462     lua_pushnil(raw(state));
 463     ATF_REQUIRE(!state.is_string(-1));
 464     ATF_REQUIRE(state.is_string(-2));
 465     lua_pushstring(raw(state), "foo");
 466     ATF_REQUIRE(state.is_string(-1));
 467     ATF_REQUIRE(!state.is_string(-2));
 468     ATF_REQUIRE(state.is_string(-3));
 469     lua_pop(raw(state), 3);
 470 }
 471
 472
 473 ATF_TEST_CASE_WITHOUT_HEAD(is_table__empty);
 474 ATF_TEST_CASE_BODY(is_table__empty)
 475 {
 476     lutok::state state;
 477     ATF_REQUIRE(!state.is_table(-1));
 478 }
 479
 480
 481 ATF_TEST_CASE_WITHOUT_HEAD(is_table__ok);
 482 ATF_TEST_CASE_BODY(is_table__ok)
 483 {
 484     lutok::state state;
 485     luaL_dostring(raw(state), "t = {3, 4, 5}");
 486
 487     lua_pushstring(raw(state), "foo");
 488     ATF_REQUIRE(!state.is_table(-1));
 489     lua_getglobal(raw(state), "t");
 490     ATF_REQUIRE(state.is_table(-1));
 491     ATF_REQUIRE(!state.is_table(-2));
 492     lua_pop(raw(state), 2);
 493 }
 494
 495
 496 ATF_TEST_CASE_WITHOUT_HEAD(is_userdata__empty);
 497 ATF_TEST_CASE_BODY(is_userdata__empty)
 498 {
 499     lutok::state state;
 500     ATF_REQUIRE(!state.is_userdata(-1));
 501 }
 502
 503
 504 ATF_TEST_CASE_WITHOUT_HEAD(is_userdata__ok);
 505 ATF_TEST_CASE_BODY(is_userdata__ok)
 506 {
 507     lutok::state state;
 508
 509     lua_pushstring(raw(state), "foo");
 510     ATF_REQUIRE(!state.is_userdata(-1));
 511     lua_newuserdata(raw(state), 543);
 512     ATF_REQUIRE(state.is_userdata(-1));
 513     ATF_REQUIRE(!state.is_userdata(-2));
 514     lua_pop(raw(state), 2);
 515 }
 516
 517
 518 ATF_TEST_CASE_WITHOUT_HEAD(load_file__ok);
 519 ATF_TEST_CASE_BODY(load_file__ok)
 520 {
 521     std::ofstream output("test.lua");
 522     output << "in_the_file = \"oh yes\"\n";
 523     output.close();
 524
 525     lutok::state state;
 526     state.load_file("test.lua");
 527     ATF_REQUIRE(lua_pcall(raw(state), 0, 0, 0) == 0);
 528     lua_getglobal(raw(state), "in_the_file");
 529     ATF_REQUIRE(std::strcmp("oh yes", lua_tostring(raw(state), -1)) == 0);
 530     lua_pop(raw(state), 1);
 531 }
 532
 533
 534 ATF_TEST_CASE_WITHOUT_HEAD(load_file__api_error);
 535 ATF_TEST_CASE_BODY(load_file__api_error)
 536 {
 537     std::ofstream output("test.lua");
 538     output << "I have a bad syntax!  Wohoo!\n";
 539     output.close();
 540
 541     lutok::state state;
 542     REQUIRE_API_ERROR("luaL_loadfile", state.load_file("test.lua"));
 543 }
 544
 545
 546 ATF_TEST_CASE_WITHOUT_HEAD(load_file__file_not_found_error);
 547 ATF_TEST_CASE_BODY(load_file__file_not_found_error)
 548 {
 549     lutok::state state;
 550     ATF_REQUIRE_THROW_RE(lutok::file_not_found_error, "missing.lua",
 551                          state.load_file("missing.lua"));
 552 }
 553
 554
 555 ATF_TEST_CASE_WITHOUT_HEAD(load_string__ok);
 556 ATF_TEST_CASE_BODY(load_string__ok)
 557 {
 558     lutok::state state;
 559     state.load_string("return 2 + 3");
 560     ATF_REQUIRE(lua_pcall(raw(state), 0, 1, 0) == 0);
 561     ATF_REQUIRE_EQ(5, lua_tointeger(raw(state), -1));
 562     lua_pop(raw(state), 1);
 563 }
 564
 565
 566 ATF_TEST_CASE_WITHOUT_HEAD(load_string__fail);
 567 ATF_TEST_CASE_BODY(load_string__fail)
 568 {
 569     lutok::state state;
 570     REQUIRE_API_ERROR("luaL_loadstring", state.load_string("-"));
 571 }
 572
 573
 574 ATF_TEST_CASE_WITHOUT_HEAD(new_table);
 575 ATF_TEST_CASE_BODY(new_table)
 576 {
 577     lutok::state state;
 578     state.new_table();
 579     ATF_REQUIRE_EQ(1, lua_gettop(raw(state)));
 580     ATF_REQUIRE(lua_istable(raw(state), -1));
 581     lua_pop(raw(state), 1);
 582 }
 583
 584
 585 ATF_TEST_CASE_WITHOUT_HEAD(new_userdata);
 586 ATF_TEST_CASE_BODY(new_userdata)
 587 {
 588     lutok::state state;
 589     int* pointer = state.new_userdata< int >();
 590     *pointer = 1234;
 591     ATF_REQUIRE_EQ(1, lua_gettop(raw(state)));
 592     ATF_REQUIRE(lua_isuserdata(raw(state), -1));
 593     lua_pop(raw(state), 1);
 594 }
 595
 596
 597 ATF_TEST_CASE_WITHOUT_HEAD(next__empty);
 598 ATF_TEST_CASE_BODY(next__empty)
 599 {
 600     lutok::state state;
 601     luaL_dostring(raw(state), "t = {}");
 602
 603     lua_getglobal(raw(state), "t");
 604     lua_pushstring(raw(state), "this is a dummy value");
 605     lua_pushnil(raw(state));
 606     ATF_REQUIRE(!state.next(-3));
 607     lua_pop(raw(state), 2);
 608 }
 609
 610
 611 ATF_TEST_CASE_WITHOUT_HEAD(next__many);
 612 ATF_TEST_CASE_BODY(next__many)
 613 {
 614     lutok::state state;
 615     luaL_dostring(raw(state), "t = {}; t[1] = 100; t[2] = 200");
 616
 617     lua_getglobal(raw(state), "t");
 618     lua_pushnil(raw(state));
 619
 620     ATF_REQUIRE(state.next(-2));
 621     ATF_REQUIRE_EQ(3, lua_gettop(raw(state)));
 622     ATF_REQUIRE(lua_isnumber(raw(state), -2));
 623     ATF_REQUIRE_EQ(1, lua_tointeger(raw(state), -2));
 624     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 625     ATF_REQUIRE_EQ(100, lua_tointeger(raw(state), -1));
 626     lua_pop(raw(state), 1);
 627
 628     ATF_REQUIRE(state.next(-2));
 629     ATF_REQUIRE_EQ(3, lua_gettop(raw(state)));
 630     ATF_REQUIRE(lua_isnumber(raw(state), -2));
 631     ATF_REQUIRE_EQ(2, lua_tointeger(raw(state), -2));
 632     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 633     ATF_REQUIRE_EQ(200, lua_tointeger(raw(state), -1));
 634     lua_pop(raw(state), 1);
 635
 636     ATF_REQUIRE(!state.next(-2));
 637     lua_pop(raw(state), 1);
 638 }
 639
 640
 641 ATF_TEST_CASE_WITHOUT_HEAD(open_base);
 642 ATF_TEST_CASE_BODY(open_base)
 643 {
 644     lutok::state state;
 645     check_modules(state, "");
 646     state.open_base();
 647     check_modules(state, "base");
 648 }
 649
 650
 651 ATF_TEST_CASE_WITHOUT_HEAD(open_all);
 652 ATF_TEST_CASE_BODY(open_all)
 653 {
 654     lutok::state state;
 655     check_modules(state, "");
 656     state.open_all();
 657     // Best-effort attempt at looking for a bunch of possible modules.
 658     ATF_REQUIRE(is_available(state, "assert"));
 659     ATF_REQUIRE(is_available(state, "debug.getinfo"));
 660     ATF_REQUIRE(is_available(state, "package.path"));
 661     ATF_REQUIRE(is_available(state, "string.byte"));
 662     ATF_REQUIRE(is_available(state, "table.concat"));
 663 }
 664
 665
 666 ATF_TEST_CASE_WITHOUT_HEAD(open_string);
 667 ATF_TEST_CASE_BODY(open_string)
 668 {
 669     lutok::state state;
 670     check_modules(state, "");
 671     state.open_string();
 672     check_modules(state, "string");
 673 }
 674
 675
 676 ATF_TEST_CASE_WITHOUT_HEAD(open_table);
 677 ATF_TEST_CASE_BODY(open_table)
 678 {
 679     lutok::state state;
 680     check_modules(state, "");
 681     state.open_table();
 682     check_modules(state, "table");
 683 }
 684
 685
 686 ATF_TEST_CASE_WITHOUT_HEAD(pcall__ok);
 687 ATF_TEST_CASE_BODY(pcall__ok)
 688 {
 689     lutok::state state;
 690     luaL_loadstring(raw(state), "function mul(a, b) return a * b; end");
 691     state.pcall(0, 0, 0);
 692     state.get_global_table();
 693     lua_pushstring(raw(state), "mul");
 694     lua_gettable(raw(state), -2);
 695     lua_pushinteger(raw(state), 3);
 696     lua_pushinteger(raw(state), 5);
 697     state.pcall(2, 1, 0);
 698     ATF_REQUIRE_EQ(15, lua_tointeger(raw(state), -1));
 699     lua_pop(raw(state), 2);
 700 }
 701
 702
 703 ATF_TEST_CASE_WITHOUT_HEAD(pcall__fail);
 704 ATF_TEST_CASE_BODY(pcall__fail)
 705 {
 706     lutok::state state;
 707     lua_pushnil(raw(state));
 708     REQUIRE_API_ERROR("lua_pcall", state.pcall(0, 0, 0));
 709 }
 710
 711
 712 ATF_TEST_CASE_WITHOUT_HEAD(pop__one);
 713 ATF_TEST_CASE_BODY(pop__one)
 714 {
 715     lutok::state state;
 716     lua_pushinteger(raw(state), 10);
 717     lua_pushinteger(raw(state), 20);
 718     lua_pushinteger(raw(state), 30);
 719     state.pop(1);
 720     ATF_REQUIRE_EQ(2, lua_gettop(raw(state)));
 721     ATF_REQUIRE_EQ(20, lua_tointeger(raw(state), -1));
 722     lua_pop(raw(state), 2);
 723 }
 724
 725
 726 ATF_TEST_CASE_WITHOUT_HEAD(pop__many);
 727 ATF_TEST_CASE_BODY(pop__many)
 728 {
 729     lutok::state state;
 730     lua_pushinteger(raw(state), 10);
 731     lua_pushinteger(raw(state), 20);
 732     lua_pushinteger(raw(state), 30);
 733     state.pop(2);
 734     ATF_REQUIRE_EQ(1, lua_gettop(raw(state)));
 735     ATF_REQUIRE_EQ(10, lua_tointeger(raw(state), -1));
 736     lua_pop(raw(state), 1);
 737 }
 738
 739
 740 ATF_TEST_CASE_WITHOUT_HEAD(push_boolean);
 741 ATF_TEST_CASE_BODY(push_boolean)
 742 {
 743     lutok::state state;
 744     state.push_boolean(true);
 745     ATF_REQUIRE_EQ(1, lua_gettop(raw(state)));
 746     ATF_REQUIRE(lua_toboolean(raw(state), -1));
 747     state.push_boolean(false);
 748     ATF_REQUIRE_EQ(2, lua_gettop(raw(state)));
 749     ATF_REQUIRE(!lua_toboolean(raw(state), -1));
 750     ATF_REQUIRE(lua_toboolean(raw(state), -2));
 751     lua_pop(raw(state), 2);
 752 }
 753
 754
 755 ATF_TEST_CASE_WITHOUT_HEAD(push_cxx_closure);
 756 ATF_TEST_CASE_BODY(push_cxx_closure)
 757 {
 758     lutok::state state;
 759     state.push_integer(15);
 760     state.push_cxx_closure(cxx_multiply_closure, 1);
 761     lua_setglobal(raw(state), "cxx_multiply_closure");
 762
 763     ATF_REQUIRE(luaL_dostring(raw(state),
 764                               "return cxx_multiply_closure(10)") == 0);
 765     ATF_REQUIRE_EQ(150, lua_tointeger(raw(state), -1));
 766     lua_pop(raw(state), 1);
 767 }
 768
 769
 770 ATF_TEST_CASE_WITHOUT_HEAD(push_cxx_function__ok);
 771 ATF_TEST_CASE_BODY(push_cxx_function__ok)
 772 {
 773     lutok::state state;
 774     state.push_cxx_function(cxx_divide);
 775     lua_setglobal(raw(state), "cxx_divide");
 776
 777     ATF_REQUIRE(luaL_dostring(raw(state), "return cxx_divide(17, 3)") == 0);
 778     ATF_REQUIRE_EQ(5, lua_tointeger(raw(state), -2));
 779     ATF_REQUIRE_EQ(2, lua_tointeger(raw(state), -1));
 780     lua_pop(raw(state), 2);
 781 }
 782
 783
 784 ATF_TEST_CASE_WITHOUT_HEAD(push_cxx_function__fail_exception);
 785 ATF_TEST_CASE_BODY(push_cxx_function__fail_exception)
 786 {
 787     lutok::state state;
 788     state.push_cxx_function(cxx_divide);
 789     lua_setglobal(raw(state), "cxx_divide");
 790
 791     ATF_REQUIRE(luaL_dostring(raw(state), "return cxx_divide(15, 0)") != 0);
 792     ATF_REQUIRE_MATCH("Divisor is 0", lua_tostring(raw(state), -1));
 793     lua_pop(raw(state), 1);
 794 }
 795
 796
 797 ATF_TEST_CASE_WITHOUT_HEAD(push_cxx_function__fail_anything);
 798 ATF_TEST_CASE_BODY(push_cxx_function__fail_anything)
 799 {
 800     lutok::state state;
 801     state.push_cxx_function(cxx_divide);
 802     lua_setglobal(raw(state), "cxx_divide");
 803
 804     ATF_REQUIRE(luaL_dostring(raw(state), "return cxx_divide(-3, -1)") != 0);
 805     ATF_REQUIRE_MATCH("Unhandled exception", lua_tostring(raw(state), -1));
 806     lua_pop(raw(state), 1);
 807 }
 808
 809
 810 ATF_TEST_CASE_WITHOUT_HEAD(push_cxx_function__fail_overflow);
 811 ATF_TEST_CASE_BODY(push_cxx_function__fail_overflow)
 812 {
 813     lutok::state state;
 814     state.push_cxx_function(raise_long_error);
 815     lua_setglobal(raw(state), "fail");
 816
 817     ATF_REQUIRE(luaL_dostring(raw(state), "return fail(900)") != 0);
 818     ATF_REQUIRE_MATCH(std::string(900, 'A'), lua_tostring(raw(state), -1));
 819     lua_pop(raw(state), 1);
 820
 821     ATF_REQUIRE(luaL_dostring(raw(state), "return fail(8192)") != 0);
 822     ATF_REQUIRE_MATCH(std::string(900, 'A'), lua_tostring(raw(state), -1));
 823     lua_pop(raw(state), 1);
 824 }
 825
 826
 827 ATF_TEST_CASE_WITHOUT_HEAD(push_integer);
 828 ATF_TEST_CASE_BODY(push_integer)
 829 {
 830     lutok::state state;
 831     state.push_integer(12);
 832     ATF_REQUIRE_EQ(1, lua_gettop(raw(state)));
 833     ATF_REQUIRE_EQ(12, lua_tointeger(raw(state), -1));
 834     state.push_integer(34);
 835     ATF_REQUIRE_EQ(2, lua_gettop(raw(state)));
 836     ATF_REQUIRE_EQ(34, lua_tointeger(raw(state), -1));
 837     ATF_REQUIRE_EQ(12, lua_tointeger(raw(state), -2));
 838     lua_pop(raw(state), 2);
 839 }
 840
 841
 842 ATF_TEST_CASE_WITHOUT_HEAD(push_nil);
 843 ATF_TEST_CASE_BODY(push_nil)
 844 {
 845     lutok::state state;
 846     state.push_nil();
 847     ATF_REQUIRE_EQ(1, lua_gettop(raw(state)));
 848     ATF_REQUIRE(lua_isnil(raw(state), -1));
 849     state.push_integer(34);
 850     ATF_REQUIRE_EQ(2, lua_gettop(raw(state)));
 851     ATF_REQUIRE(!lua_isnil(raw(state), -1));
 852     ATF_REQUIRE(lua_isnil(raw(state), -2));
 853     lua_pop(raw(state), 2);
 854 }
 855
 856
 857 ATF_TEST_CASE_WITHOUT_HEAD(push_string);
 858 ATF_TEST_CASE_BODY(push_string)
 859 {
 860     lutok::state state;
 861
 862     {
 863         std::string str = "first";
 864         state.push_string(str);
 865         ATF_REQUIRE_EQ(1, lua_gettop(raw(state)));
 866         ATF_REQUIRE_EQ(std::string("first"), lua_tostring(raw(state), -1));
 867         str = "second";
 868         state.push_string(str);
 869     }
 870     ATF_REQUIRE_EQ(2, lua_gettop(raw(state)));
 871     ATF_REQUIRE_EQ(std::string("second"), lua_tostring(raw(state), -1));
 872     ATF_REQUIRE_EQ(std::string("first"), lua_tostring(raw(state), -2));
 873     lua_pop(raw(state), 2);
 874 }
 875
 876
 877 ATF_TEST_CASE_WITHOUT_HEAD(push_value);
 878 ATF_TEST_CASE_BODY(push_value)
 879 {
 880     lutok::state state;
 881
 882     lua_pushinteger(raw(state), 10);
 883     lua_pushinteger(raw(state), 20);
 884     state.push_value(-2);
 885     ATF_REQUIRE_EQ(3, lua_gettop(raw(state)));
 886     ATF_REQUIRE_EQ(10, lua_tointeger(raw(state), -1));
 887     ATF_REQUIRE_EQ(20, lua_tointeger(raw(state), -2));
 888     ATF_REQUIRE_EQ(10, lua_tointeger(raw(state), -3));
 889     lua_pop(raw(state), 3);
 890 }
 891
 892
 893 ATF_TEST_CASE_WITHOUT_HEAD(raw_get);
 894 ATF_TEST_CASE_BODY(raw_get)
 895 {
 896     lutok::state state;
 897
 898     luaL_openlibs(raw(state));
 899     ATF_REQUIRE(luaL_dostring(
 900         raw(state), "t = {foo=123} ; setmetatable(t, {__index=1})") == 0);
 901     lua_getglobal(raw(state), "t");
 902     lua_pushinteger(raw(state), 9876);
 903     lua_pushstring(raw(state), "foo");
 904     state.raw_get(-3);
 905     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 906     ATF_REQUIRE_EQ(123, lua_tointeger(raw(state), -1));
 907     ATF_REQUIRE_EQ(9876, lua_tointeger(raw(state), -2));
 908     lua_pop(raw(state), 3);
 909 }
 910
 911
 912 ATF_TEST_CASE_WITHOUT_HEAD(raw_set);
 913 ATF_TEST_CASE_BODY(raw_set)
 914 {
 915     lutok::state state;
 916
 917     luaL_openlibs(raw(state));
 918     ATF_REQUIRE(luaL_dostring(
 919         raw(state), "t = {} ; setmetatable(t, {__newindex=1})") == 0);
 920     lua_getglobal(raw(state), "t");
 921     lua_pushinteger(raw(state), 876);
 922     lua_pushstring(raw(state), "foo");
 923     lua_pushinteger(raw(state), 345);
 924     state.raw_set(-4);
 925     ATF_REQUIRE(luaL_dostring(raw(state), "return t.foo") == 0);
 926     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 927     ATF_REQUIRE_EQ(345, lua_tointeger(raw(state), -1));
 928     ATF_REQUIRE_EQ(876, lua_tointeger(raw(state), -2));
 929     lua_pop(raw(state), 3);
 930 }
 931
 932
 933 ATF_TEST_CASE_WITHOUT_HEAD(registry_index);
 934 ATF_TEST_CASE_BODY(registry_index)
 935 {
 936     lutok::state state;
 937     lua_pushvalue(raw(state), lutok::registry_index);
 938     lua_pushstring(raw(state), "custom_variable");
 939     lua_pushstring(raw(state), "custom value");
 940     lua_settable(raw(state), -3);
 941     lua_pop(raw(state), 1);
 942     ATF_REQUIRE(luaL_dostring(raw(state),
 943                               "return custom_variable == nil") == 0);
 944     ATF_REQUIRE(lua_isboolean(raw(state), -1));
 945     ATF_REQUIRE(lua_toboolean(raw(state), -1));
 946     lua_pop(raw(state), 1);
 947 }
 948
 949
 950 ATF_TEST_CASE_WITHOUT_HEAD(set_global);
 951 ATF_TEST_CASE_BODY(set_global)
 952 {
 953     lutok::state state;
 954     lua_pushinteger(raw(state), 3);
 955     state.set_global("test_variable");
 956     ATF_REQUIRE(luaL_dostring(raw(state), "return test_variable + 1") == 0);
 957     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 958     ATF_REQUIRE_EQ(4, lua_tointeger(raw(state), -1));
 959     lua_pop(raw(state), 1);
 960 }
 961
 962
 963 ATF_TEST_CASE_WITHOUT_HEAD(set_metatable);
 964 ATF_TEST_CASE_BODY(set_metatable)
 965 {
 966     lutok::state state;
 967     ATF_REQUIRE(luaL_dostring(
 968         raw(state),
 969         "mt = {}\n"
 970         "mt.__add = function(a, b) return a[1] + b end\n"
 971         "numbers = {}\n"
 972         "numbers[1] = 5\n") == 0);
 973
 974     lua_getglobal(raw(state), "numbers");
 975     lua_pushinteger(raw(state), 1234);
 976     lua_getglobal(raw(state), "mt");
 977     state.set_metatable(-3);
 978     lua_pop(raw(state), 2);
 979
 980     ATF_REQUIRE(luaL_dostring(raw(state), "return numbers + 2") == 0);
 981     ATF_REQUIRE(lua_isnumber(raw(state), -1));
 982     ATF_REQUIRE_EQ(7, lua_tointeger(raw(state), -1));
 983     lua_pop(raw(state), 1);
 984 }
 985
 986
 987 ATF_TEST_CASE_WITHOUT_HEAD(set_table__ok);
 988 ATF_TEST_CASE_BODY(set_table__ok)
 989 {
 990     lutok::state state;
 991     ATF_REQUIRE(luaL_dostring(raw(state), "t = { a = 1, bar = 234 }") == 0);
 992     lua_getglobal(raw(state), "t");
 993
 994     lua_pushstring(raw(state), "bar");
 995     lua_pushstring(raw(state), "baz");
 996     state.set_table(-3);
 997     ATF_REQUIRE_EQ(1, lua_gettop(raw(state)));
 998
 999     lua_pushstring(raw(state), "a");
1000     lua_gettable(raw(state), -2);
1001     ATF_REQUIRE(lua_isnumber(raw(state), -1));
1002     ATF_REQUIRE_EQ(1, lua_tointeger(raw(state), -1));
1003     lua_pop(raw(state), 1);
1004
1005     lua_pushstring(raw(state), "bar");
1006     lua_gettable(raw(state), -2);
1007     ATF_REQUIRE(lua_isstring(raw(state), -1));
1008     ATF_REQUIRE_EQ(std::string("baz"), lua_tostring(raw(state), -1));
1009     lua_pop(raw(state), 1);
1010
1011     lua_pop(raw(state), 1);
1012 }
1013
1014
1015 ATF_TEST_CASE_WITHOUT_HEAD(set_table__nil);
1016 ATF_TEST_CASE_BODY(set_table__nil)
1017 {
1018     lutok::state state;
1019     lua_pushnil(raw(state));
1020     lua_pushinteger(raw(state), 1);
1021     lua_pushinteger(raw(state), 2);
1022     REQUIRE_API_ERROR("lua_settable", state.set_table(-3));
1023     lua_pop(raw(state), 3);
1024 }
1025
1026
1027 ATF_TEST_CASE_WITHOUT_HEAD(to_boolean);
1028 ATF_TEST_CASE_BODY(to_boolean)
1029 {
1030     lutok::state state;
1031     lua_pushboolean(raw(state), 0);
1032     lua_pushboolean(raw(state), 1);
1033     ATF_REQUIRE(!state.to_boolean(-2));
1034     ATF_REQUIRE(state.to_boolean(-1));
1035     lua_pop(raw(state), 2);
1036 }
1037
1038
1039 ATF_TEST_CASE_WITHOUT_HEAD(to_integer);
1040 ATF_TEST_CASE_BODY(to_integer)
1041 {
1042     lutok::state state;
1043     lua_pushinteger(raw(state), 12);
1044     lua_pushstring(raw(state), "foobar");
1045     ATF_REQUIRE_EQ(12, state.to_integer(-2));
1046     lua_pop(raw(state), 2);
1047 }
1048
1049
1050 ATF_TEST_CASE_WITHOUT_HEAD(to_string);
1051 ATF_TEST_CASE_BODY(to_string)
1052 {
1053     lutok::state state;
1054     lua_pushstring(raw(state), "foobar");
1055     lua_pushinteger(raw(state), 12);
1056     ATF_REQUIRE_EQ("foobar", state.to_string(-2));
1057     ATF_REQUIRE_EQ("12", state.to_string(-1));
1058     lua_pop(raw(state), 2);
1059 }
1060
1061
1062 ATF_TEST_CASE_WITHOUT_HEAD(to_userdata);
1063 ATF_TEST_CASE_BODY(to_userdata)
1064 {
1065     lutok::state state;
1066     {
1067         int* pointer = static_cast< int* >(
1068             lua_newuserdata(raw(state), sizeof(int)));
1069         *pointer = 987;
1070     }
1071
1072     lua_pushinteger(raw(state), 3);
1073     int* pointer = state.to_userdata< int >(-2);
1074     ATF_REQUIRE_EQ(987, *pointer);
1075     lua_pop(raw(state), 2);
1076 }
1077
1078
1079 ATF_TEST_CASE_WITHOUT_HEAD(upvalue_index);
1080 ATF_TEST_CASE_BODY(upvalue_index)
1081 {
1082     lutok::state state;
1083     lua_pushinteger(raw(state), 25);
1084     lua_pushinteger(raw(state), 30);
1085     lua_pushcclosure(raw(state), c_get_upvalues, 2);
1086     lua_setglobal(raw(state), "c_get_upvalues");
1087
1088     ATF_REQUIRE(luaL_dostring(raw(state),
1089                               "return c_get_upvalues()") == 0);
1090     ATF_REQUIRE_EQ(25, lua_tointeger(raw(state), -2));
1091     ATF_REQUIRE_EQ(30, lua_tointeger(raw(state), -1));
1092     lua_pop(raw(state), 2);
1093 }
1094
1095
1096 ATF_INIT_TEST_CASES(tcs)
1097 {
1098     ATF_ADD_TEST_CASE(tcs, close);
1099     ATF_ADD_TEST_CASE(tcs, get_global__ok);
1100     ATF_ADD_TEST_CASE(tcs, get_global__undefined);
1101     ATF_ADD_TEST_CASE(tcs, get_global_table);
1102     ATF_ADD_TEST_CASE(tcs, get_metafield__ok);
1103     ATF_ADD_TEST_CASE(tcs, get_metafield__undefined);
1104     ATF_ADD_TEST_CASE(tcs, get_metatable__ok);
1105     ATF_ADD_TEST_CASE(tcs, get_metatable__undefined);
1106     ATF_ADD_TEST_CASE(tcs, get_table__ok);
1107     ATF_ADD_TEST_CASE(tcs, get_table__nil);
1108     ATF_ADD_TEST_CASE(tcs, get_table__unknown_index);
1109     ATF_ADD_TEST_CASE(tcs, get_top);
1110     ATF_ADD_TEST_CASE(tcs, insert);
1111     ATF_ADD_TEST_CASE(tcs, is_boolean__empty);
1112     ATF_ADD_TEST_CASE(tcs, is_boolean__ok);
1113     ATF_ADD_TEST_CASE(tcs, is_function__empty);
1114     ATF_ADD_TEST_CASE(tcs, is_function__ok);
1115     ATF_ADD_TEST_CASE(tcs, is_nil__empty);
1116     ATF_ADD_TEST_CASE(tcs, is_nil__ok);
1117     ATF_ADD_TEST_CASE(tcs, is_number__empty);
1118     ATF_ADD_TEST_CASE(tcs, is_number__ok);
1119     ATF_ADD_TEST_CASE(tcs, is_string__empty);
1120     ATF_ADD_TEST_CASE(tcs, is_string__ok);
1121     ATF_ADD_TEST_CASE(tcs, is_table__empty);
1122     ATF_ADD_TEST_CASE(tcs, is_table__ok);
1123     ATF_ADD_TEST_CASE(tcs, is_userdata__empty);
1124     ATF_ADD_TEST_CASE(tcs, is_userdata__ok);
1125     ATF_ADD_TEST_CASE(tcs, load_file__ok);
1126     ATF_ADD_TEST_CASE(tcs, load_file__api_error);
1127     ATF_ADD_TEST_CASE(tcs, load_file__file_not_found_error);
1128     ATF_ADD_TEST_CASE(tcs, load_string__ok);
1129     ATF_ADD_TEST_CASE(tcs, load_string__fail);
1130     ATF_ADD_TEST_CASE(tcs, new_table);
1131     ATF_ADD_TEST_CASE(tcs, new_userdata);
1132     ATF_ADD_TEST_CASE(tcs, next__empty);
1133     ATF_ADD_TEST_CASE(tcs, next__many);
1134     ATF_ADD_TEST_CASE(tcs, open_all);
1135     ATF_ADD_TEST_CASE(tcs, open_base);
1136     ATF_ADD_TEST_CASE(tcs, open_string);
1137     ATF_ADD_TEST_CASE(tcs, open_table);
1138     ATF_ADD_TEST_CASE(tcs, pcall__ok);
1139     ATF_ADD_TEST_CASE(tcs, pcall__fail);
1140     ATF_ADD_TEST_CASE(tcs, pop__one);
1141     ATF_ADD_TEST_CASE(tcs, pop__many);
1142     ATF_ADD_TEST_CASE(tcs, push_boolean);
1143     ATF_ADD_TEST_CASE(tcs, push_cxx_closure);
1144     ATF_ADD_TEST_CASE(tcs, push_cxx_function__ok);
1145     ATF_ADD_TEST_CASE(tcs, push_cxx_function__fail_exception);
1146     ATF_ADD_TEST_CASE(tcs, push_cxx_function__fail_anything);
1147     ATF_ADD_TEST_CASE(tcs, push_cxx_function__fail_overflow);
1148     ATF_ADD_TEST_CASE(tcs, push_integer);
1149     ATF_ADD_TEST_CASE(tcs, push_nil);
1150     ATF_ADD_TEST_CASE(tcs, push_string);
1151     ATF_ADD_TEST_CASE(tcs, push_value);
1152     ATF_ADD_TEST_CASE(tcs, raw_get);
1153     ATF_ADD_TEST_CASE(tcs, raw_set);
1154     ATF_ADD_TEST_CASE(tcs, registry_index);
1155     ATF_ADD_TEST_CASE(tcs, set_global);
1156     ATF_ADD_TEST_CASE(tcs, set_metatable);
1157     ATF_ADD_TEST_CASE(tcs, set_table__ok);
1158     ATF_ADD_TEST_CASE(tcs, set_table__nil);
1159     ATF_ADD_TEST_CASE(tcs, to_boolean);
1160     ATF_ADD_TEST_CASE(tcs, to_integer);
1161     ATF_ADD_TEST_CASE(tcs, to_string);
1162     ATF_ADD_TEST_CASE(tcs, to_userdata);
1163     ATF_ADD_TEST_CASE(tcs, upvalue_index);
1164 }