From de7cacf9732464b9b4dd54920a1a235558644480 Mon Sep 17 00:00:00 2001 From: Julio Merino Date: Fri, 16 Sep 2011 21:15:01 +0000 Subject: [PATCH] Split the wrap module into state and stack_cleaner modules The wrap module used to contain two very different classes: state, which is the lightweight wrapper over the Lua C API, and stack_cleaner, which is our own creation to deal with inconsistencies in the Lua stack. These classes belong in different modules, so this is exactly what this change does. This change was r6 in Subversion. --- Atffile | 3 +- Kyuafile | 3 +- Makefile.am | 26 +- configure.ac | 2 +- exceptions.cpp | 2 +- include/lutok/Makefile.am.inc | 3 +- include/lutok/stack_cleaner.hpp | 1 + include/lutok/state.hpp | 1 + include/lutok/wrap.hpp | 1 - operations.cpp | 3 +- operations.hpp | 2 +- operations_test.cpp | 2 +- stack_cleaner.cpp | 91 ++++++ stack_cleaner.hpp | 86 ++++++ stack_cleaner_test.cpp | 108 +++++++ wrap.cpp => state.cpp | 63 +--- wrap.hpp => state.hpp | 54 +--- wrap.ipp => state.ipp | 8 +- wrap_test.cpp => state_test.cpp | 513 ++++++++++++++------------------ test_utils.hpp | 2 +- 20 files changed, 547 insertions(+), 427 deletions(-) create mode 100644 include/lutok/stack_cleaner.hpp create mode 100644 include/lutok/state.hpp delete mode 100644 include/lutok/wrap.hpp create mode 100644 stack_cleaner.cpp create mode 100644 stack_cleaner.hpp create mode 100644 stack_cleaner_test.cpp rename wrap.cpp => state.cpp (91%) rename wrap.hpp => state.hpp (74%) rename wrap.ipp => state.ipp (96%) rename wrap_test.cpp => state_test.cpp (67%) diff --git a/Atffile b/Atffile index 40b469c..5f31246 100644 --- a/Atffile +++ b/Atffile @@ -4,4 +4,5 @@ prop: test-suite = lutok tp: exceptions_test tp: operations_test -tp: wrap_test +tp: stack_cleaner_test +tp: state_test diff --git a/Kyuafile b/Kyuafile index 2e942a3..9b3f63a 100644 --- a/Kyuafile +++ b/Kyuafile @@ -4,4 +4,5 @@ test_suite("lutok") atf_test_program{name="exceptions_test"} atf_test_program{name="operations_test"} -atf_test_program{name="wrap_test"} +atf_test_program{name="stack_cleaner_test"} +atf_test_program{name="state_test"} diff --git a/Makefile.am b/Makefile.am index 21940f1..4c4b07f 100644 --- a/Makefile.am +++ b/Makefile.am @@ -41,9 +41,10 @@ LUTOK_LIBS = liblutok.la $(LUA_LIBS) pkginclude_HEADERS = exceptions.hpp pkginclude_HEADERS += noncopyable.hpp pkginclude_HEADERS += operations.hpp +pkginclude_HEADERS += stack_cleaner.hpp +pkginclude_HEADERS += state.hpp +pkginclude_HEADERS += state.ipp pkginclude_HEADERS += test_utils.hpp -pkginclude_HEADERS += wrap.hpp -pkginclude_HEADERS += wrap.ipp lib_LTLIBRARIES = liblutok.la liblutok_la_SOURCES = exceptions.cpp @@ -51,10 +52,12 @@ liblutok_la_SOURCES += exceptions.hpp liblutok_la_SOURCES += noncopyable.hpp liblutok_la_SOURCES += operations.cpp liblutok_la_SOURCES += operations.hpp +liblutok_la_SOURCES += stack_cleaner.cpp +liblutok_la_SOURCES += stack_cleaner.hpp +liblutok_la_SOURCES += state.cpp +liblutok_la_SOURCES += state.hpp +liblutok_la_SOURCES += state.ipp liblutok_la_SOURCES += test_utils.hpp -liblutok_la_SOURCES += wrap.cpp -liblutok_la_SOURCES += wrap.hpp -liblutok_la_SOURCES += wrap.ipp liblutok_la_CPPFLAGS = -I$(srcdir)/include $(LUA_CFLAGS) liblutok_la_LDFLAGS = -version-info 0:0:0 liblutok_la_LIBADD = $(LUA_LIBS) @@ -88,10 +91,15 @@ operations_test_SOURCES = operations_test.cpp test_utils.hpp operations_test_CXXFLAGS = $(ATF_CXX_CFLAGS) $(LUTOK_CFLAGS) operations_test_LDADD = $(ATF_CXX_LIBS) $(LUTOK_LIBS) -tests_PROGRAMS += wrap_test -wrap_test_SOURCES = test_utils.hpp wrap_test.cpp -wrap_test_CXXFLAGS = $(ATF_CXX_CFLAGS) $(LUTOK_CFLAGS) -wrap_test_LDADD = $(ATF_CXX_LIBS) $(LUTOK_LIBS) +tests_PROGRAMS += stack_cleaner_test +stack_cleaner_test_SOURCES = stack_cleaner_test.cpp test_utils.hpp +stack_cleaner_test_CXXFLAGS = $(ATF_CXX_CFLAGS) $(LUTOK_CFLAGS) +stack_cleaner_test_LDADD = $(ATF_CXX_LIBS) $(LUTOK_LIBS) + +tests_PROGRAMS += state_test +state_test_SOURCES = state_test.cpp test_utils.hpp +state_test_CXXFLAGS = $(ATF_CXX_CFLAGS) $(LUTOK_CFLAGS) +state_test_LDADD = $(ATF_CXX_LIBS) $(LUTOK_LIBS) check-local: check-kyua PHONY_TARGETS += check-kyua diff --git a/configure.ac b/configure.ac index 3c40535..4bf6c31 100644 --- a/configure.ac +++ b/configure.ac @@ -37,7 +37,7 @@ AC_CONFIG_AUX_DIR([admin]) AC_CONFIG_FILES([Doxyfile Makefile]) AC_CONFIG_HEADERS([config.h]) AC_CONFIG_MACRO_DIR([m4]) -AC_CONFIG_SRCDIR([wrap.hpp]) +AC_CONFIG_SRCDIR([state.hpp]) AM_INIT_AUTOMAKE([1.9 check-news foreign subdir-objects -Wall]) diff --git a/exceptions.cpp b/exceptions.cpp index a740812..75f7cde 100644 --- a/exceptions.cpp +++ b/exceptions.cpp @@ -31,7 +31,7 @@ #include #include "exceptions.hpp" -#include "wrap.hpp" +#include "state.hpp" /// Constructs a new error with a plain-text message. diff --git a/include/lutok/Makefile.am.inc b/include/lutok/Makefile.am.inc index 412df8e..55d56e6 100644 --- a/include/lutok/Makefile.am.inc +++ b/include/lutok/Makefile.am.inc @@ -29,4 +29,5 @@ EXTRA_DIST+= include/lutok/exceptions.hpp EXTRA_DIST+= include/lutok/noncopyable.hpp EXTRA_DIST+= include/lutok/operations.hpp -EXTRA_DIST+= include/lutok/wrap.hpp +EXTRA_DIST+= include/lutok/stack_cleaner.hpp +EXTRA_DIST+= include/lutok/state.hpp diff --git a/include/lutok/stack_cleaner.hpp b/include/lutok/stack_cleaner.hpp new file mode 100644 index 0000000..99edfb8 --- /dev/null +++ b/include/lutok/stack_cleaner.hpp @@ -0,0 +1 @@ +#include "../../stack_cleaner.hpp" diff --git a/include/lutok/state.hpp b/include/lutok/state.hpp new file mode 100644 index 0000000..48ac65c --- /dev/null +++ b/include/lutok/state.hpp @@ -0,0 +1 @@ +#include "../../state.hpp" diff --git a/include/lutok/wrap.hpp b/include/lutok/wrap.hpp deleted file mode 100644 index 9e69003..0000000 --- a/include/lutok/wrap.hpp +++ /dev/null @@ -1 +0,0 @@ -#include "../../wrap.hpp" diff --git a/operations.cpp b/operations.cpp index 088c008..ee28bf5 100644 --- a/operations.cpp +++ b/operations.cpp @@ -30,7 +30,8 @@ #include "exceptions.hpp" #include "operations.hpp" -#include "wrap.hpp" +#include "stack_cleaner.hpp" +#include "state.hpp" /// Creates a module: i.e. a table with a set of methods in it. diff --git a/operations.hpp b/operations.hpp index 39ff68d..79729ac 100644 --- a/operations.hpp +++ b/operations.hpp @@ -36,7 +36,7 @@ #include #include -#include +#include namespace lutok { diff --git a/operations_test.cpp b/operations_test.cpp index c19de7f..fc6208c 100644 --- a/operations_test.cpp +++ b/operations_test.cpp @@ -32,8 +32,8 @@ #include "exceptions.hpp" #include "operations.hpp" +#include "state.ipp" #include "test_utils.hpp" -#include "wrap.ipp" namespace { diff --git a/stack_cleaner.cpp b/stack_cleaner.cpp new file mode 100644 index 0000000..419e55a --- /dev/null +++ b/stack_cleaner.cpp @@ -0,0 +1,91 @@ +// Copyright 2011 Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Google Inc. nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include +#include + +#include "stack_cleaner.hpp" +#include "state.ipp" + + +/// Internal implementation for lutok::stack_cleaner. +struct lutok::stack_cleaner::impl { + /// Reference to the Lua state this stack_cleaner refers to. + state& state_ref; + + /// The depth of the Lua stack to be restored. + unsigned int original_depth; + + /// Constructor. + /// + /// \param state_ref_ Reference to the Lua state. + /// \param original_depth_ The depth of the Lua stack. + impl(state& state_ref_, const unsigned int original_depth_) : + state_ref(state_ref_), + original_depth(original_depth_) + { + } +}; + + +/// Creates a new stack cleaner. +/// +/// This gathers the current height of the stack so that extra elements can be +/// popped during destruction. +/// +/// \param state_ The Lua state. +lutok::stack_cleaner::stack_cleaner(state& state_) : + _pimpl(new impl(state_, state_.get_top())) +{ +} + + +/// Pops any values from the stack not known at construction time. +/// +/// \pre The current height of the stack must be equal or greater to the height +/// of the stack when this object was instantiated. +lutok::stack_cleaner::~stack_cleaner(void) +{ + const unsigned int current_depth = _pimpl->state_ref.get_top(); + assert(current_depth >= _pimpl->original_depth); + const unsigned int diff = current_depth - _pimpl->original_depth; + if (diff > 0) + _pimpl->state_ref.pop(diff); +} + + +/// Forgets about any elements currently in the stack. +/// +/// This allows a function to return values on the stack because all the +/// elements that are currently in the stack will not be touched during +/// destruction when the function is called. +void +lutok::stack_cleaner::forget(void) +{ + _pimpl->original_depth = _pimpl->state_ref.get_top(); +} diff --git a/stack_cleaner.hpp b/stack_cleaner.hpp new file mode 100644 index 0000000..2722cd2 --- /dev/null +++ b/stack_cleaner.hpp @@ -0,0 +1,86 @@ +// Copyright 2011 Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Google Inc. nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/// \file stack_cleaner.hpp +/// Provides the stack_cleaner class. + +#if !defined(LUTOK_STACK_CLEANER_HPP) +#define LUTOK_STACK_CLEANER_HPP + +#include + +#include +#include + +namespace lutok { + + +/// A RAII model for values on the Lua stack. +/// +/// At creation time, the object records the current depth of the Lua stack and, +/// during destruction, restores the recorded depth by popping as many stack +/// entries as required. As a corollary, the stack can only grow during the +/// lifetime of a stack_cleaner object (or shrink, but cannot become shorter +/// than the depth recorded at creation time). +/// +/// Use this class as follows: +/// +/// state s; +/// { +/// stack_cleaner cleaner1(s); +/// s.push_integer(3); +/// s.push_integer(5); +/// ... do stuff here ... +/// for (...) { +/// stack_cleaner cleaner2(s); +/// s.load_string("..."); +/// s.pcall(0, 1, 0); +/// ... do stuff here ... +/// } +/// // cleaner2 destroyed; the result of pcall is gone. +/// } +/// // cleaner1 destroyed; the integers 3 and 5 are gone. +/// +/// You must give a name to the instantiated objects even if they cannot be +/// accessed later. Otherwise, the instance will be destroyed right away and +/// will not have the desired effect. +class stack_cleaner : noncopyable { + struct impl; + std::auto_ptr< impl > _pimpl; + +public: + stack_cleaner(state&); + ~stack_cleaner(void); + + void forget(void); +}; + + +} // namespace lutok + +#endif // !defined(LUTOK_STACK_CLEANER_HPP) diff --git a/stack_cleaner_test.cpp b/stack_cleaner_test.cpp new file mode 100644 index 0000000..5e21ca7 --- /dev/null +++ b/stack_cleaner_test.cpp @@ -0,0 +1,108 @@ +// Copyright 2011 Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Google Inc. nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include + +#include "stack_cleaner.hpp" + + +ATF_TEST_CASE_WITHOUT_HEAD(empty); +ATF_TEST_CASE_BODY(empty) +{ + lutok::state state; + { + lutok::stack_cleaner cleaner(state); + ATF_REQUIRE_EQ(0, state.get_top()); + } + ATF_REQUIRE_EQ(0, state.get_top()); +} + + +ATF_TEST_CASE_WITHOUT_HEAD(some); +ATF_TEST_CASE_BODY(some) +{ + lutok::state state; + { + lutok::stack_cleaner cleaner(state); + state.push_integer(15); + ATF_REQUIRE_EQ(1, state.get_top()); + state.push_integer(30); + ATF_REQUIRE_EQ(2, state.get_top()); + } + ATF_REQUIRE_EQ(0, state.get_top()); +} + + +ATF_TEST_CASE_WITHOUT_HEAD(nested); +ATF_TEST_CASE_BODY(nested) +{ + lutok::state state; + { + lutok::stack_cleaner cleaner1(state); + state.push_integer(10); + ATF_REQUIRE_EQ(1, state.get_top()); + ATF_REQUIRE_EQ(10, state.to_integer()); + { + lutok::stack_cleaner cleaner2(state); + state.push_integer(20); + ATF_REQUIRE_EQ(2, state.get_top()); + ATF_REQUIRE_EQ(20, state.to_integer(-1)); + ATF_REQUIRE_EQ(10, state.to_integer(-2)); + } + ATF_REQUIRE_EQ(1, state.get_top()); + ATF_REQUIRE_EQ(10, state.to_integer()); + } + ATF_REQUIRE_EQ(0, state.get_top()); +} + + +ATF_TEST_CASE_WITHOUT_HEAD(forget); +ATF_TEST_CASE_BODY(forget) +{ + lutok::state state; + { + lutok::stack_cleaner cleaner(state); + state.push_integer(15); + state.push_integer(30); + cleaner.forget(); + state.push_integer(60); + ATF_REQUIRE_EQ(3, state.get_top()); + } + ATF_REQUIRE_EQ(2, state.get_top()); + ATF_REQUIRE_EQ(30, state.to_integer()); + state.pop(2); +} + + +ATF_INIT_TEST_CASES(tcs) +{ + ATF_ADD_TEST_CASE(tcs, empty); + ATF_ADD_TEST_CASE(tcs, some); + ATF_ADD_TEST_CASE(tcs, nested); + ATF_ADD_TEST_CASE(tcs, forget); +} diff --git a/wrap.cpp b/state.cpp similarity index 91% rename from wrap.cpp rename to state.cpp index 2f1c6ee..05f8e80 100644 --- a/wrap.cpp +++ b/state.cpp @@ -34,7 +34,7 @@ extern "C" { #include #include "exceptions.hpp" -#include "wrap.ipp" +#include "state.ipp" namespace { @@ -718,67 +718,6 @@ lutok::state::raw_state_for_testing(void) } -/// Internal implementation for lutok::stack_cleaner. -struct lutok::stack_cleaner::impl { - /// Reference to the Lua state this stack_cleaner refers to. - state& state_ref; - - /// The depth of the Lua stack to be restored. - unsigned int original_depth; - - /// Constructor. - /// - /// \param state_ref_ Reference to the Lua state. - /// \param original_depth_ The depth of the Lua stack. - impl(state& state_ref_, const unsigned int original_depth_) : - state_ref(state_ref_), - original_depth(original_depth_) - { - } -}; - - -/// Creates a new stack cleaner. -/// -/// This gathers the current height of the stack so that extra elements can be -/// popped during destruction. -/// -/// \param state_ The Lua state. -lutok::stack_cleaner::stack_cleaner(state& state_) : - _pimpl(new impl(state_, state_.get_top())) -{ -} - - -/// Pops any values from the stack not known at construction time. -/// -/// \pre The current height of the stack must be equal or greater to the height -/// of the stack when this object was instantiated. -lutok::stack_cleaner::~stack_cleaner(void) -{ - const unsigned int current_depth = _pimpl->state_ref.get_top(); - //assert(current_depth >= _pimpl->original_depth, - // F("Unbalanced scope: current stack depth %d < original %d") % - // current_depth % _pimpl->original_depth); - assert(current_depth >= _pimpl->original_depth); - const unsigned int diff = current_depth - _pimpl->original_depth; - if (diff > 0) - _pimpl->state_ref.pop(diff); -} - - -/// Forgets about any elements currently in the stack. -/// -/// This allows a function to return values on the stack because all the -/// elements that are currently in the stack will not be touched during -/// destruction when the function is called. -void -lutok::stack_cleaner::forget(void) -{ - _pimpl->original_depth = _pimpl->state_ref.get_top(); -} - - /// Calls a C++ Lua function from a C calling environment. /// /// Any errors reported by the C++ function are caught and reported to the diff --git a/wrap.hpp b/state.hpp similarity index 74% rename from wrap.hpp rename to state.hpp index dafad08..663b5ab 100644 --- a/wrap.hpp +++ b/state.hpp @@ -26,14 +26,11 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -/// \file wrap.hpp -/// Wrapper classes and utilities for the Lua C library. -/// -/// This module contains thin RAII wrappers around the Lua structures and -/// lightweight, safer wrapper methods around the Lua C API. +/// \file state.hpp +/// Provides the state wrapper class for the Lua C state. -#if !defined(LUTOK_WRAP_HPP) -#define LUTOK_WRAP_HPP +#if !defined(LUTOK_STATE_HPP) +#define LUTOK_STATE_HPP #include #include @@ -128,47 +125,6 @@ class state : noncopyable { }; -/// A RAII model for values on the Lua stack. -/// -/// At creation time, the object records the current depth of the Lua stack and, -/// during destruction, restores the recorded depth by popping as many stack -/// entries as required. As a corollary, the stack can only grow during the -/// lifetime of a stack_cleaner object (or shrink, but cannot become shorter -/// than the depth recorded at creation time). -/// -/// Use this class as follows: -/// -/// state s; -/// { -/// stack_cleaner cleaner1(s); -/// s.push_integer(3); -/// s.push_integer(5); -/// ... do stuff here ... -/// for (...) { -/// stack_cleaner cleaner2(s); -/// s.load_string("..."); -/// s.pcall(0, 1, 0); -/// ... do stuff here ... -/// } -/// // cleaner2 destroyed; the result of pcall is gone. -/// } -/// // cleaner1 destroyed; the integers 3 and 5 are gone. -/// -/// You must give a name to the instantiated objects even if they cannot be -/// accessed later. Otherwise, the instance will be destroyed right away and -/// will not have the desired effect. -class stack_cleaner : noncopyable { - struct impl; - std::auto_ptr< impl > _pimpl; - -public: - stack_cleaner(state&); - ~stack_cleaner(void); - - void forget(void); -}; - - } // namespace lutok -#endif // !defined(LUTOK_WRAP_HPP) +#endif // !defined(LUTOK_STATE_HPP) diff --git a/wrap.ipp b/state.ipp similarity index 96% rename from wrap.ipp rename to state.ipp index 33ccc86..2928cdd 100644 --- a/wrap.ipp +++ b/state.ipp @@ -26,12 +26,12 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -#if !defined(LUTOK_WRAP_IPP) -#define LUTOK_WRAP_IPP +#if !defined(LUTOK_STATE_IPP) +#define LUTOK_STATE_IPP #include -#include +#include namespace lutok { @@ -103,4 +103,4 @@ state::to_userdata(const int index) } // namespace lutok -#endif // !defined(LUTOK_WRAP_IPP) +#endif // !defined(LUTOK_STATE_IPP) diff --git a/wrap_test.cpp b/state_test.cpp similarity index 67% rename from wrap_test.cpp rename to state_test.cpp index 12eec9e..ec615e9 100644 --- a/wrap_test.cpp +++ b/state_test.cpp @@ -35,8 +35,8 @@ #include #include "exceptions.hpp" +#include "state.ipp" #include "test_utils.hpp" -#include "wrap.ipp" // A note about the lutok::state tests. @@ -202,8 +202,8 @@ raise_long_error(lutok::state& state) } // anonymous namespace -ATF_TEST_CASE_WITHOUT_HEAD(state__ctor_only_wrap); -ATF_TEST_CASE_BODY(state__ctor_only_wrap) +ATF_TEST_CASE_WITHOUT_HEAD(ctor_only_wrap); +ATF_TEST_CASE_BODY(ctor_only_wrap) { lua_State* raw_state = lua_open(); ATF_REQUIRE(raw_state != NULL); @@ -220,8 +220,8 @@ ATF_TEST_CASE_BODY(state__ctor_only_wrap) } -ATF_TEST_CASE_WITHOUT_HEAD(state__close); -ATF_TEST_CASE_BODY(state__close) +ATF_TEST_CASE_WITHOUT_HEAD(close); +ATF_TEST_CASE_BODY(close) { lutok::state state; state.close(); @@ -230,8 +230,8 @@ ATF_TEST_CASE_BODY(state__close) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_global__ok); -ATF_TEST_CASE_BODY(state__get_global__ok) +ATF_TEST_CASE_WITHOUT_HEAD(get_global__ok); +ATF_TEST_CASE_BODY(get_global__ok) { lutok::state state; ATF_REQUIRE(luaL_dostring(raw(state), "test_variable = 3") == 0); @@ -241,8 +241,8 @@ ATF_TEST_CASE_BODY(state__get_global__ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_global__fail); -ATF_TEST_CASE_BODY(state__get_global__fail) +ATF_TEST_CASE_WITHOUT_HEAD(get_global__fail); +ATF_TEST_CASE_BODY(get_global__fail) { lutok::state state; lua_pushinteger(raw(state), 3); @@ -251,8 +251,8 @@ ATF_TEST_CASE_BODY(state__get_global__fail) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_global__undefined); -ATF_TEST_CASE_BODY(state__get_global__undefined) +ATF_TEST_CASE_WITHOUT_HEAD(get_global__undefined); +ATF_TEST_CASE_BODY(get_global__undefined) { lutok::state state; state.get_global("test_variable"); @@ -261,8 +261,8 @@ ATF_TEST_CASE_BODY(state__get_global__undefined) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_info); -ATF_TEST_CASE_BODY(state__get_info) +ATF_TEST_CASE_WITHOUT_HEAD(get_info); +ATF_TEST_CASE_BODY(get_info) { lutok::state state; ATF_REQUIRE(luaL_dostring(raw(state), "\n\nfunction hello() end\n" @@ -273,8 +273,8 @@ ATF_TEST_CASE_BODY(state__get_info) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_stack); -ATF_TEST_CASE_BODY(state__get_stack) +ATF_TEST_CASE_WITHOUT_HEAD(get_stack); +ATF_TEST_CASE_BODY(get_stack) { lutok::state state; lutok::debug ar; @@ -287,8 +287,8 @@ ATF_TEST_CASE_BODY(state__get_stack) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_table__ok); -ATF_TEST_CASE_BODY(state__get_table__ok) +ATF_TEST_CASE_WITHOUT_HEAD(get_table__ok); +ATF_TEST_CASE_BODY(get_table__ok) { lutok::state state; ATF_REQUIRE(luaL_dostring(raw(state), "t = { a = 1, bar = 234 }") == 0); @@ -301,8 +301,8 @@ ATF_TEST_CASE_BODY(state__get_table__ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_table__nil); -ATF_TEST_CASE_BODY(state__get_table__nil) +ATF_TEST_CASE_WITHOUT_HEAD(get_table__nil); +ATF_TEST_CASE_BODY(get_table__nil) { lutok::state state; lua_pushnil(raw(state)); @@ -313,8 +313,8 @@ ATF_TEST_CASE_BODY(state__get_table__nil) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_table__unknown_index); -ATF_TEST_CASE_BODY(state__get_table__unknown_index) +ATF_TEST_CASE_WITHOUT_HEAD(get_table__unknown_index); +ATF_TEST_CASE_BODY(get_table__unknown_index) { lutok::state state; ATF_REQUIRE(luaL_dostring(raw(state), @@ -327,8 +327,8 @@ ATF_TEST_CASE_BODY(state__get_table__unknown_index) } -ATF_TEST_CASE_WITHOUT_HEAD(state__get_top); -ATF_TEST_CASE_BODY(state__get_top) +ATF_TEST_CASE_WITHOUT_HEAD(get_top); +ATF_TEST_CASE_BODY(get_top) { lutok::state state; ATF_REQUIRE_EQ(0, state.get_top()); @@ -340,16 +340,16 @@ ATF_TEST_CASE_BODY(state__get_top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_boolean__empty); -ATF_TEST_CASE_BODY(state__is_boolean__empty) +ATF_TEST_CASE_WITHOUT_HEAD(is_boolean__empty); +ATF_TEST_CASE_BODY(is_boolean__empty) { lutok::state state; ATF_REQUIRE(!state.is_boolean()); } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_boolean__top); -ATF_TEST_CASE_BODY(state__is_boolean__top) +ATF_TEST_CASE_WITHOUT_HEAD(is_boolean__top); +ATF_TEST_CASE_BODY(is_boolean__top) { lutok::state state; lua_pushnil(raw(state)); @@ -360,8 +360,8 @@ ATF_TEST_CASE_BODY(state__is_boolean__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_boolean__explicit); -ATF_TEST_CASE_BODY(state__is_boolean__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(is_boolean__explicit); +ATF_TEST_CASE_BODY(is_boolean__explicit) { lutok::state state; lua_pushboolean(raw(state), 1); @@ -373,16 +373,16 @@ ATF_TEST_CASE_BODY(state__is_boolean__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_function__empty); -ATF_TEST_CASE_BODY(state__is_function__empty) +ATF_TEST_CASE_WITHOUT_HEAD(is_function__empty); +ATF_TEST_CASE_BODY(is_function__empty) { lutok::state state; ATF_REQUIRE(!state.is_function()); } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_function__top); -ATF_TEST_CASE_BODY(state__is_function__top) +ATF_TEST_CASE_WITHOUT_HEAD(is_function__top); +ATF_TEST_CASE_BODY(is_function__top) { lutok::state state; luaL_dostring(raw(state), "function my_func(a, b) return a + b; end"); @@ -395,8 +395,8 @@ ATF_TEST_CASE_BODY(state__is_function__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_function__explicit); -ATF_TEST_CASE_BODY(state__is_function__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(is_function__explicit); +ATF_TEST_CASE_BODY(is_function__explicit) { lutok::state state; luaL_dostring(raw(state), "function my_func(a, b) return a + b; end"); @@ -410,16 +410,16 @@ ATF_TEST_CASE_BODY(state__is_function__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_nil__empty); -ATF_TEST_CASE_BODY(state__is_nil__empty) +ATF_TEST_CASE_WITHOUT_HEAD(is_nil__empty); +ATF_TEST_CASE_BODY(is_nil__empty) { lutok::state state; ATF_REQUIRE(state.is_nil()); } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_nil__top); -ATF_TEST_CASE_BODY(state__is_nil__top) +ATF_TEST_CASE_WITHOUT_HEAD(is_nil__top); +ATF_TEST_CASE_BODY(is_nil__top) { lutok::state state; lua_pushnil(raw(state)); @@ -430,8 +430,8 @@ ATF_TEST_CASE_BODY(state__is_nil__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_nil__explicit); -ATF_TEST_CASE_BODY(state__is_nil__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(is_nil__explicit); +ATF_TEST_CASE_BODY(is_nil__explicit) { lutok::state state; lua_pushnil(raw(state)); @@ -443,16 +443,16 @@ ATF_TEST_CASE_BODY(state__is_nil__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_number__empty); -ATF_TEST_CASE_BODY(state__is_number__empty) +ATF_TEST_CASE_WITHOUT_HEAD(is_number__empty); +ATF_TEST_CASE_BODY(is_number__empty) { lutok::state state; ATF_REQUIRE(!state.is_number()); } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_number__top); -ATF_TEST_CASE_BODY(state__is_number__top) +ATF_TEST_CASE_WITHOUT_HEAD(is_number__top); +ATF_TEST_CASE_BODY(is_number__top) { lutok::state state; lua_pushnil(raw(state)); @@ -463,8 +463,8 @@ ATF_TEST_CASE_BODY(state__is_number__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_number__explicit); -ATF_TEST_CASE_BODY(state__is_number__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(is_number__explicit); +ATF_TEST_CASE_BODY(is_number__explicit) { lutok::state state; lua_pushnil(raw(state)); @@ -476,16 +476,16 @@ ATF_TEST_CASE_BODY(state__is_number__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_string__empty); -ATF_TEST_CASE_BODY(state__is_string__empty) +ATF_TEST_CASE_WITHOUT_HEAD(is_string__empty); +ATF_TEST_CASE_BODY(is_string__empty) { lutok::state state; ATF_REQUIRE(!state.is_string()); } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_string__top); -ATF_TEST_CASE_BODY(state__is_string__top) +ATF_TEST_CASE_WITHOUT_HEAD(is_string__top); +ATF_TEST_CASE_BODY(is_string__top) { lutok::state state; lua_pushnil(raw(state)); @@ -498,8 +498,8 @@ ATF_TEST_CASE_BODY(state__is_string__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_string__explicit); -ATF_TEST_CASE_BODY(state__is_string__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(is_string__explicit); +ATF_TEST_CASE_BODY(is_string__explicit) { lutok::state state; lua_pushinteger(raw(state), 3); @@ -515,16 +515,16 @@ ATF_TEST_CASE_BODY(state__is_string__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_table__empty); -ATF_TEST_CASE_BODY(state__is_table__empty) +ATF_TEST_CASE_WITHOUT_HEAD(is_table__empty); +ATF_TEST_CASE_BODY(is_table__empty) { lutok::state state; ATF_REQUIRE(!state.is_table()); } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_table__top); -ATF_TEST_CASE_BODY(state__is_table__top) +ATF_TEST_CASE_WITHOUT_HEAD(is_table__top); +ATF_TEST_CASE_BODY(is_table__top) { lutok::state state; luaL_dostring(raw(state), "t = {3, 4, 5}"); @@ -537,8 +537,8 @@ ATF_TEST_CASE_BODY(state__is_table__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_table__explicit); -ATF_TEST_CASE_BODY(state__is_table__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(is_table__explicit); +ATF_TEST_CASE_BODY(is_table__explicit) { lutok::state state; luaL_dostring(raw(state), "t = {3, 4, 5}"); @@ -552,16 +552,16 @@ ATF_TEST_CASE_BODY(state__is_table__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_userdata__empty); -ATF_TEST_CASE_BODY(state__is_userdata__empty) +ATF_TEST_CASE_WITHOUT_HEAD(is_userdata__empty); +ATF_TEST_CASE_BODY(is_userdata__empty) { lutok::state state; ATF_REQUIRE(!state.is_userdata()); } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_userdata__top); -ATF_TEST_CASE_BODY(state__is_userdata__top) +ATF_TEST_CASE_WITHOUT_HEAD(is_userdata__top); +ATF_TEST_CASE_BODY(is_userdata__top) { lutok::state state; @@ -573,8 +573,8 @@ ATF_TEST_CASE_BODY(state__is_userdata__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__is_userdata__explicit); -ATF_TEST_CASE_BODY(state__is_userdata__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(is_userdata__explicit); +ATF_TEST_CASE_BODY(is_userdata__explicit) { lutok::state state; @@ -587,8 +587,8 @@ ATF_TEST_CASE_BODY(state__is_userdata__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__load_file__ok); -ATF_TEST_CASE_BODY(state__load_file__ok) +ATF_TEST_CASE_WITHOUT_HEAD(load_file__ok); +ATF_TEST_CASE_BODY(load_file__ok) { std::ofstream output("test.lua"); output << "in_the_file = \"oh yes\"\n"; @@ -603,8 +603,8 @@ ATF_TEST_CASE_BODY(state__load_file__ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__load_file__api_error); -ATF_TEST_CASE_BODY(state__load_file__api_error) +ATF_TEST_CASE_WITHOUT_HEAD(load_file__api_error); +ATF_TEST_CASE_BODY(load_file__api_error) { std::ofstream output("test.lua"); output << "I have a bad syntax! Wohoo!\n"; @@ -615,8 +615,8 @@ ATF_TEST_CASE_BODY(state__load_file__api_error) } -ATF_TEST_CASE_WITHOUT_HEAD(state__load_file__file_not_found_error); -ATF_TEST_CASE_BODY(state__load_file__file_not_found_error) +ATF_TEST_CASE_WITHOUT_HEAD(load_file__file_not_found_error); +ATF_TEST_CASE_BODY(load_file__file_not_found_error) { lutok::state state; ATF_REQUIRE_THROW_RE(lutok::file_not_found_error, "missing.lua", @@ -624,8 +624,8 @@ ATF_TEST_CASE_BODY(state__load_file__file_not_found_error) } -ATF_TEST_CASE_WITHOUT_HEAD(state__load_string__ok); -ATF_TEST_CASE_BODY(state__load_string__ok) +ATF_TEST_CASE_WITHOUT_HEAD(load_string__ok); +ATF_TEST_CASE_BODY(load_string__ok) { lutok::state state; state.load_string("return 2 + 3"); @@ -635,16 +635,16 @@ ATF_TEST_CASE_BODY(state__load_string__ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__load_string__fail); -ATF_TEST_CASE_BODY(state__load_string__fail) +ATF_TEST_CASE_WITHOUT_HEAD(load_string__fail); +ATF_TEST_CASE_BODY(load_string__fail) { lutok::state state; REQUIRE_API_ERROR("luaL_loadstring", state.load_string("-")); } -ATF_TEST_CASE_WITHOUT_HEAD(state__new_table); -ATF_TEST_CASE_BODY(state__new_table) +ATF_TEST_CASE_WITHOUT_HEAD(new_table); +ATF_TEST_CASE_BODY(new_table) { lutok::state state; state.new_table(); @@ -654,8 +654,8 @@ ATF_TEST_CASE_BODY(state__new_table) } -ATF_TEST_CASE_WITHOUT_HEAD(state__new_userdata); -ATF_TEST_CASE_BODY(state__new_userdata) +ATF_TEST_CASE_WITHOUT_HEAD(new_userdata); +ATF_TEST_CASE_BODY(new_userdata) { lutok::state state; int* pointer = state.new_userdata< int >(); @@ -666,8 +666,8 @@ ATF_TEST_CASE_BODY(state__new_userdata) } -ATF_TEST_CASE_WITHOUT_HEAD(state__next__empty); -ATF_TEST_CASE_BODY(state__next__empty) +ATF_TEST_CASE_WITHOUT_HEAD(next__empty); +ATF_TEST_CASE_BODY(next__empty) { lutok::state state; luaL_dostring(raw(state), "t = {}"); @@ -680,8 +680,8 @@ ATF_TEST_CASE_BODY(state__next__empty) } -ATF_TEST_CASE_WITHOUT_HEAD(state__next__many); -ATF_TEST_CASE_BODY(state__next__many) +ATF_TEST_CASE_WITHOUT_HEAD(next__many); +ATF_TEST_CASE_BODY(next__many) { lutok::state state; luaL_dostring(raw(state), "t = {}; t[1] = 100; t[2] = 200"); @@ -710,8 +710,8 @@ ATF_TEST_CASE_BODY(state__next__many) } -ATF_TEST_CASE_WITHOUT_HEAD(state__open_base); -ATF_TEST_CASE_BODY(state__open_base) +ATF_TEST_CASE_WITHOUT_HEAD(open_base); +ATF_TEST_CASE_BODY(open_base) { lutok::state state; check_modules(state, ""); @@ -720,8 +720,8 @@ ATF_TEST_CASE_BODY(state__open_base) } -ATF_TEST_CASE_WITHOUT_HEAD(state__open_string); -ATF_TEST_CASE_BODY(state__open_string) +ATF_TEST_CASE_WITHOUT_HEAD(open_string); +ATF_TEST_CASE_BODY(open_string) { lutok::state state; check_modules(state, ""); @@ -730,8 +730,8 @@ ATF_TEST_CASE_BODY(state__open_string) } -ATF_TEST_CASE_WITHOUT_HEAD(state__open_table); -ATF_TEST_CASE_BODY(state__open_table) +ATF_TEST_CASE_WITHOUT_HEAD(open_table); +ATF_TEST_CASE_BODY(open_table) { lutok::state state; check_modules(state, ""); @@ -740,8 +740,8 @@ ATF_TEST_CASE_BODY(state__open_table) } -ATF_TEST_CASE_WITHOUT_HEAD(state__pcall__ok); -ATF_TEST_CASE_BODY(state__pcall__ok) +ATF_TEST_CASE_WITHOUT_HEAD(pcall__ok); +ATF_TEST_CASE_BODY(pcall__ok) { lutok::state state; luaL_loadstring(raw(state), "function mul(a, b) return a * b; end"); @@ -755,8 +755,8 @@ ATF_TEST_CASE_BODY(state__pcall__ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__pcall__fail); -ATF_TEST_CASE_BODY(state__pcall__fail) +ATF_TEST_CASE_WITHOUT_HEAD(pcall__fail); +ATF_TEST_CASE_BODY(pcall__fail) { lutok::state state; lua_pushnil(raw(state)); @@ -764,8 +764,8 @@ ATF_TEST_CASE_BODY(state__pcall__fail) } -ATF_TEST_CASE_WITHOUT_HEAD(state__pop__one); -ATF_TEST_CASE_BODY(state__pop__one) +ATF_TEST_CASE_WITHOUT_HEAD(pop__one); +ATF_TEST_CASE_BODY(pop__one) { lutok::state state; lua_pushinteger(raw(state), 10); @@ -778,8 +778,8 @@ ATF_TEST_CASE_BODY(state__pop__one) } -ATF_TEST_CASE_WITHOUT_HEAD(state__pop__many); -ATF_TEST_CASE_BODY(state__pop__many) +ATF_TEST_CASE_WITHOUT_HEAD(pop__many); +ATF_TEST_CASE_BODY(pop__many) { lutok::state state; lua_pushinteger(raw(state), 10); @@ -792,8 +792,8 @@ ATF_TEST_CASE_BODY(state__pop__many) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_boolean); -ATF_TEST_CASE_BODY(state__push_boolean) +ATF_TEST_CASE_WITHOUT_HEAD(push_boolean); +ATF_TEST_CASE_BODY(push_boolean) { lutok::state state; state.push_boolean(true); @@ -807,8 +807,8 @@ ATF_TEST_CASE_BODY(state__push_boolean) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_c_closure); -ATF_TEST_CASE_BODY(state__push_c_closure) +ATF_TEST_CASE_WITHOUT_HEAD(push_c_closure); +ATF_TEST_CASE_BODY(push_c_closure) { lutok::state state; state.push_integer(15); @@ -822,8 +822,8 @@ ATF_TEST_CASE_BODY(state__push_c_closure) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_c_function__c_ok); -ATF_TEST_CASE_BODY(state__push_c_function__c_ok) +ATF_TEST_CASE_WITHOUT_HEAD(push_c_function__c_ok); +ATF_TEST_CASE_BODY(push_c_function__c_ok) { lutok::state state; state.push_c_function(c_multiply); @@ -835,8 +835,8 @@ ATF_TEST_CASE_BODY(state__push_c_function__c_ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_c_function__cxx_ok); -ATF_TEST_CASE_BODY(state__push_c_function__cxx_ok) +ATF_TEST_CASE_WITHOUT_HEAD(push_c_function__cxx_ok); +ATF_TEST_CASE_BODY(push_c_function__cxx_ok) { lutok::state state; state.push_c_function(lutok::wrap_cxx_function< cxx_divide >); @@ -849,8 +849,8 @@ ATF_TEST_CASE_BODY(state__push_c_function__cxx_ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_c_function__cxx_fail_exception); -ATF_TEST_CASE_BODY(state__push_c_function__cxx_fail_exception) +ATF_TEST_CASE_WITHOUT_HEAD(push_c_function__cxx_fail_exception); +ATF_TEST_CASE_BODY(push_c_function__cxx_fail_exception) { lutok::state state; state.push_c_function(lutok::wrap_cxx_function< cxx_divide >); @@ -862,8 +862,8 @@ ATF_TEST_CASE_BODY(state__push_c_function__cxx_fail_exception) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_c_function__cxx_fail_anything); -ATF_TEST_CASE_BODY(state__push_c_function__cxx_fail_anything) +ATF_TEST_CASE_WITHOUT_HEAD(push_c_function__cxx_fail_anything); +ATF_TEST_CASE_BODY(push_c_function__cxx_fail_anything) { lutok::state state; state.push_c_function(lutok::wrap_cxx_function< cxx_divide >); @@ -875,8 +875,8 @@ ATF_TEST_CASE_BODY(state__push_c_function__cxx_fail_anything) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_c_function__cxx_fail_overflow); -ATF_TEST_CASE_BODY(state__push_c_function__cxx_fail_overflow) +ATF_TEST_CASE_WITHOUT_HEAD(push_c_function__cxx_fail_overflow); +ATF_TEST_CASE_BODY(push_c_function__cxx_fail_overflow) { lutok::state state; state.push_c_function(lutok::wrap_cxx_function< raise_long_error >); @@ -892,8 +892,8 @@ ATF_TEST_CASE_BODY(state__push_c_function__cxx_fail_overflow) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_integer); -ATF_TEST_CASE_BODY(state__push_integer) +ATF_TEST_CASE_WITHOUT_HEAD(push_integer); +ATF_TEST_CASE_BODY(push_integer) { lutok::state state; state.push_integer(12); @@ -907,8 +907,8 @@ ATF_TEST_CASE_BODY(state__push_integer) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_nil); -ATF_TEST_CASE_BODY(state__push_nil) +ATF_TEST_CASE_WITHOUT_HEAD(push_nil); +ATF_TEST_CASE_BODY(push_nil) { lutok::state state; state.push_nil(); @@ -922,8 +922,8 @@ ATF_TEST_CASE_BODY(state__push_nil) } -ATF_TEST_CASE_WITHOUT_HEAD(state__push_string); -ATF_TEST_CASE_BODY(state__push_string) +ATF_TEST_CASE_WITHOUT_HEAD(push_string); +ATF_TEST_CASE_BODY(push_string) { lutok::state state; @@ -942,8 +942,8 @@ ATF_TEST_CASE_BODY(state__push_string) } -ATF_TEST_CASE_WITHOUT_HEAD(state__set_global__ok); -ATF_TEST_CASE_BODY(state__set_global__ok) +ATF_TEST_CASE_WITHOUT_HEAD(set_global__ok); +ATF_TEST_CASE_BODY(set_global__ok) { lutok::state state; lua_pushinteger(raw(state), 3); @@ -955,8 +955,8 @@ ATF_TEST_CASE_BODY(state__set_global__ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__set_global__fail); -ATF_TEST_CASE_BODY(state__set_global__fail) +ATF_TEST_CASE_WITHOUT_HEAD(set_global__fail); +ATF_TEST_CASE_BODY(set_global__fail) { lutok::state state; lua_pushinteger(raw(state), 3); @@ -967,8 +967,8 @@ ATF_TEST_CASE_BODY(state__set_global__fail) } -ATF_TEST_CASE_WITHOUT_HEAD(state__set_metatable__top); -ATF_TEST_CASE_BODY(state__set_metatable__top) +ATF_TEST_CASE_WITHOUT_HEAD(set_metatable__top); +ATF_TEST_CASE_BODY(set_metatable__top) { lutok::state state; ATF_REQUIRE(luaL_dostring( @@ -990,8 +990,8 @@ ATF_TEST_CASE_BODY(state__set_metatable__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__set_metatable__explicit); -ATF_TEST_CASE_BODY(state__set_metatable__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(set_metatable__explicit); +ATF_TEST_CASE_BODY(set_metatable__explicit) { lutok::state state; ATF_REQUIRE(luaL_dostring( @@ -1014,8 +1014,8 @@ ATF_TEST_CASE_BODY(state__set_metatable__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__set_table__ok); -ATF_TEST_CASE_BODY(state__set_table__ok) +ATF_TEST_CASE_WITHOUT_HEAD(set_table__ok); +ATF_TEST_CASE_BODY(set_table__ok) { lutok::state state; ATF_REQUIRE(luaL_dostring(raw(state), "t = { a = 1, bar = 234 }") == 0); @@ -1042,8 +1042,8 @@ ATF_TEST_CASE_BODY(state__set_table__ok) } -ATF_TEST_CASE_WITHOUT_HEAD(state__set_table__nil); -ATF_TEST_CASE_BODY(state__set_table__nil) +ATF_TEST_CASE_WITHOUT_HEAD(set_table__nil); +ATF_TEST_CASE_BODY(set_table__nil) { lutok::state state; lua_pushnil(raw(state)); @@ -1054,8 +1054,8 @@ ATF_TEST_CASE_BODY(state__set_table__nil) } -ATF_TEST_CASE_WITHOUT_HEAD(state__to_boolean__top); -ATF_TEST_CASE_BODY(state__to_boolean__top) +ATF_TEST_CASE_WITHOUT_HEAD(to_boolean__top); +ATF_TEST_CASE_BODY(to_boolean__top) { lutok::state state; lua_pushboolean(raw(state), 1); @@ -1066,8 +1066,8 @@ ATF_TEST_CASE_BODY(state__to_boolean__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__to_boolean__explicit); -ATF_TEST_CASE_BODY(state__to_boolean__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(to_boolean__explicit); +ATF_TEST_CASE_BODY(to_boolean__explicit) { lutok::state state; lua_pushboolean(raw(state), 0); @@ -1078,8 +1078,8 @@ ATF_TEST_CASE_BODY(state__to_boolean__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__to_integer__top); -ATF_TEST_CASE_BODY(state__to_integer__top) +ATF_TEST_CASE_WITHOUT_HEAD(to_integer__top); +ATF_TEST_CASE_BODY(to_integer__top) { lutok::state state; lua_pushstring(raw(state), "34"); @@ -1090,8 +1090,8 @@ ATF_TEST_CASE_BODY(state__to_integer__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__to_integer__explicit); -ATF_TEST_CASE_BODY(state__to_integer__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(to_integer__explicit); +ATF_TEST_CASE_BODY(to_integer__explicit) { lutok::state state; lua_pushinteger(raw(state), 12); @@ -1101,8 +1101,8 @@ ATF_TEST_CASE_BODY(state__to_integer__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__to_string__top); -ATF_TEST_CASE_BODY(state__to_string__top) +ATF_TEST_CASE_WITHOUT_HEAD(to_string__top); +ATF_TEST_CASE_BODY(to_string__top) { lutok::state state; lua_pushstring(raw(state), "foobar"); @@ -1113,8 +1113,8 @@ ATF_TEST_CASE_BODY(state__to_string__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__to_string__explicit); -ATF_TEST_CASE_BODY(state__to_string__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(to_string__explicit); +ATF_TEST_CASE_BODY(to_string__explicit) { lutok::state state; lua_pushstring(raw(state), "foobar"); @@ -1125,8 +1125,8 @@ ATF_TEST_CASE_BODY(state__to_string__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__to_userdata__top); -ATF_TEST_CASE_BODY(state__to_userdata__top) +ATF_TEST_CASE_WITHOUT_HEAD(to_userdata__top); +ATF_TEST_CASE_BODY(to_userdata__top) { lutok::state state; { @@ -1141,8 +1141,8 @@ ATF_TEST_CASE_BODY(state__to_userdata__top) } -ATF_TEST_CASE_WITHOUT_HEAD(state__to_userdata__explicit); -ATF_TEST_CASE_BODY(state__to_userdata__explicit) +ATF_TEST_CASE_WITHOUT_HEAD(to_userdata__explicit); +ATF_TEST_CASE_BODY(to_userdata__explicit) { lutok::state state; { @@ -1158,8 +1158,8 @@ ATF_TEST_CASE_BODY(state__to_userdata__explicit) } -ATF_TEST_CASE_WITHOUT_HEAD(state__upvalue_index); -ATF_TEST_CASE_BODY(state__upvalue_index) +ATF_TEST_CASE_WITHOUT_HEAD(upvalue_index); +ATF_TEST_CASE_BODY(upvalue_index) { lutok::state state; lua_pushinteger(raw(state), 25); @@ -1175,152 +1175,79 @@ ATF_TEST_CASE_BODY(state__upvalue_index) } -ATF_TEST_CASE_WITHOUT_HEAD(stack_cleaner__empty); -ATF_TEST_CASE_BODY(stack_cleaner__empty) -{ - lutok::state state; - { - lutok::stack_cleaner cleaner(state); - ATF_REQUIRE_EQ(0, state.get_top()); - } - ATF_REQUIRE_EQ(0, state.get_top()); -} - - -ATF_TEST_CASE_WITHOUT_HEAD(stack_cleaner__some); -ATF_TEST_CASE_BODY(stack_cleaner__some) -{ - lutok::state state; - { - lutok::stack_cleaner cleaner(state); - state.push_integer(15); - ATF_REQUIRE_EQ(1, state.get_top()); - state.push_integer(30); - ATF_REQUIRE_EQ(2, state.get_top()); - } - ATF_REQUIRE_EQ(0, state.get_top()); -} - - -ATF_TEST_CASE_WITHOUT_HEAD(stack_cleaner__nested); -ATF_TEST_CASE_BODY(stack_cleaner__nested) -{ - lutok::state state; - { - lutok::stack_cleaner cleaner1(state); - state.push_integer(10); - ATF_REQUIRE_EQ(1, state.get_top()); - ATF_REQUIRE_EQ(10, state.to_integer()); - { - lutok::stack_cleaner cleaner2(state); - state.push_integer(20); - ATF_REQUIRE_EQ(2, state.get_top()); - ATF_REQUIRE_EQ(20, state.to_integer(-1)); - ATF_REQUIRE_EQ(10, state.to_integer(-2)); - } - ATF_REQUIRE_EQ(1, state.get_top()); - ATF_REQUIRE_EQ(10, state.to_integer()); - } - ATF_REQUIRE_EQ(0, state.get_top()); -} - - -ATF_TEST_CASE_WITHOUT_HEAD(stack_cleaner__forget); -ATF_TEST_CASE_BODY(stack_cleaner__forget) -{ - lutok::state state; - { - lutok::stack_cleaner cleaner(state); - state.push_integer(15); - state.push_integer(30); - cleaner.forget(); - state.push_integer(60); - ATF_REQUIRE_EQ(3, state.get_top()); - } - ATF_REQUIRE_EQ(2, state.get_top()); - ATF_REQUIRE_EQ(30, state.to_integer()); - state.pop(2); -} - - ATF_INIT_TEST_CASES(tcs) { - ATF_ADD_TEST_CASE(tcs, state__ctor_only_wrap); - ATF_ADD_TEST_CASE(tcs, state__close); - ATF_ADD_TEST_CASE(tcs, state__get_global__ok); - ATF_ADD_TEST_CASE(tcs, state__get_global__fail); - ATF_ADD_TEST_CASE(tcs, state__get_global__undefined); - ATF_ADD_TEST_CASE(tcs, state__get_info); - ATF_ADD_TEST_CASE(tcs, state__get_stack); - ATF_ADD_TEST_CASE(tcs, state__get_table__ok); - ATF_ADD_TEST_CASE(tcs, state__get_table__nil); - ATF_ADD_TEST_CASE(tcs, state__get_table__unknown_index); - ATF_ADD_TEST_CASE(tcs, state__get_top); - ATF_ADD_TEST_CASE(tcs, state__is_boolean__empty); - ATF_ADD_TEST_CASE(tcs, state__is_boolean__top); - ATF_ADD_TEST_CASE(tcs, state__is_boolean__explicit); - ATF_ADD_TEST_CASE(tcs, state__is_function__empty); - ATF_ADD_TEST_CASE(tcs, state__is_function__top); - ATF_ADD_TEST_CASE(tcs, state__is_function__explicit); - ATF_ADD_TEST_CASE(tcs, state__is_nil__empty); - ATF_ADD_TEST_CASE(tcs, state__is_nil__top); - ATF_ADD_TEST_CASE(tcs, state__is_nil__explicit); - ATF_ADD_TEST_CASE(tcs, state__is_number__empty); - ATF_ADD_TEST_CASE(tcs, state__is_number__top); - ATF_ADD_TEST_CASE(tcs, state__is_number__explicit); - ATF_ADD_TEST_CASE(tcs, state__is_string__empty); - ATF_ADD_TEST_CASE(tcs, state__is_string__top); - ATF_ADD_TEST_CASE(tcs, state__is_string__explicit); - ATF_ADD_TEST_CASE(tcs, state__is_table__empty); - ATF_ADD_TEST_CASE(tcs, state__is_table__top); - ATF_ADD_TEST_CASE(tcs, state__is_table__explicit); - ATF_ADD_TEST_CASE(tcs, state__is_userdata__empty); - ATF_ADD_TEST_CASE(tcs, state__is_userdata__top); - ATF_ADD_TEST_CASE(tcs, state__is_userdata__explicit); - ATF_ADD_TEST_CASE(tcs, state__load_file__ok); - ATF_ADD_TEST_CASE(tcs, state__load_file__api_error); - ATF_ADD_TEST_CASE(tcs, state__load_file__file_not_found_error); - ATF_ADD_TEST_CASE(tcs, state__load_string__ok); - ATF_ADD_TEST_CASE(tcs, state__load_string__fail); - ATF_ADD_TEST_CASE(tcs, state__new_table); - ATF_ADD_TEST_CASE(tcs, state__new_userdata); - ATF_ADD_TEST_CASE(tcs, state__next__empty); - ATF_ADD_TEST_CASE(tcs, state__next__many); - ATF_ADD_TEST_CASE(tcs, state__open_base); - ATF_ADD_TEST_CASE(tcs, state__open_string); - ATF_ADD_TEST_CASE(tcs, state__open_table); - ATF_ADD_TEST_CASE(tcs, state__pcall__ok); - ATF_ADD_TEST_CASE(tcs, state__pcall__fail); - ATF_ADD_TEST_CASE(tcs, state__pop__one); - ATF_ADD_TEST_CASE(tcs, state__pop__many); - ATF_ADD_TEST_CASE(tcs, state__push_boolean); - ATF_ADD_TEST_CASE(tcs, state__push_c_closure); - ATF_ADD_TEST_CASE(tcs, state__push_c_function__c_ok); - ATF_ADD_TEST_CASE(tcs, state__push_c_function__cxx_ok); - ATF_ADD_TEST_CASE(tcs, state__push_c_function__cxx_fail_exception); - ATF_ADD_TEST_CASE(tcs, state__push_c_function__cxx_fail_anything); - ATF_ADD_TEST_CASE(tcs, state__push_c_function__cxx_fail_overflow); - ATF_ADD_TEST_CASE(tcs, state__push_integer); - ATF_ADD_TEST_CASE(tcs, state__push_nil); - ATF_ADD_TEST_CASE(tcs, state__push_string); - ATF_ADD_TEST_CASE(tcs, state__set_global__ok); - ATF_ADD_TEST_CASE(tcs, state__set_global__fail); - ATF_ADD_TEST_CASE(tcs, state__set_metatable__top); - ATF_ADD_TEST_CASE(tcs, state__set_metatable__explicit); - ATF_ADD_TEST_CASE(tcs, state__set_table__ok); - ATF_ADD_TEST_CASE(tcs, state__set_table__nil); - ATF_ADD_TEST_CASE(tcs, state__to_boolean__top); - ATF_ADD_TEST_CASE(tcs, state__to_boolean__explicit); - ATF_ADD_TEST_CASE(tcs, state__to_integer__top); - ATF_ADD_TEST_CASE(tcs, state__to_integer__explicit); - ATF_ADD_TEST_CASE(tcs, state__to_string__top); - ATF_ADD_TEST_CASE(tcs, state__to_string__explicit); - ATF_ADD_TEST_CASE(tcs, state__to_userdata__top); - ATF_ADD_TEST_CASE(tcs, state__to_userdata__explicit); - ATF_ADD_TEST_CASE(tcs, state__upvalue_index); - - ATF_ADD_TEST_CASE(tcs, stack_cleaner__empty); - ATF_ADD_TEST_CASE(tcs, stack_cleaner__some); - ATF_ADD_TEST_CASE(tcs, stack_cleaner__nested); - ATF_ADD_TEST_CASE(tcs, stack_cleaner__forget); + ATF_ADD_TEST_CASE(tcs, ctor_only_wrap); + ATF_ADD_TEST_CASE(tcs, close); + ATF_ADD_TEST_CASE(tcs, get_global__ok); + ATF_ADD_TEST_CASE(tcs, get_global__fail); + ATF_ADD_TEST_CASE(tcs, get_global__undefined); + ATF_ADD_TEST_CASE(tcs, get_info); + ATF_ADD_TEST_CASE(tcs, get_stack); + ATF_ADD_TEST_CASE(tcs, get_table__ok); + ATF_ADD_TEST_CASE(tcs, get_table__nil); + ATF_ADD_TEST_CASE(tcs, get_table__unknown_index); + ATF_ADD_TEST_CASE(tcs, get_top); + ATF_ADD_TEST_CASE(tcs, is_boolean__empty); + ATF_ADD_TEST_CASE(tcs, is_boolean__top); + ATF_ADD_TEST_CASE(tcs, is_boolean__explicit); + ATF_ADD_TEST_CASE(tcs, is_function__empty); + ATF_ADD_TEST_CASE(tcs, is_function__top); + ATF_ADD_TEST_CASE(tcs, is_function__explicit); + ATF_ADD_TEST_CASE(tcs, is_nil__empty); + ATF_ADD_TEST_CASE(tcs, is_nil__top); + ATF_ADD_TEST_CASE(tcs, is_nil__explicit); + ATF_ADD_TEST_CASE(tcs, is_number__empty); + ATF_ADD_TEST_CASE(tcs, is_number__top); + ATF_ADD_TEST_CASE(tcs, is_number__explicit); + ATF_ADD_TEST_CASE(tcs, is_string__empty); + ATF_ADD_TEST_CASE(tcs, is_string__top); + ATF_ADD_TEST_CASE(tcs, is_string__explicit); + ATF_ADD_TEST_CASE(tcs, is_table__empty); + ATF_ADD_TEST_CASE(tcs, is_table__top); + ATF_ADD_TEST_CASE(tcs, is_table__explicit); + ATF_ADD_TEST_CASE(tcs, is_userdata__empty); + ATF_ADD_TEST_CASE(tcs, is_userdata__top); + ATF_ADD_TEST_CASE(tcs, is_userdata__explicit); + ATF_ADD_TEST_CASE(tcs, load_file__ok); + ATF_ADD_TEST_CASE(tcs, load_file__api_error); + ATF_ADD_TEST_CASE(tcs, load_file__file_not_found_error); + ATF_ADD_TEST_CASE(tcs, load_string__ok); + ATF_ADD_TEST_CASE(tcs, load_string__fail); + ATF_ADD_TEST_CASE(tcs, new_table); + ATF_ADD_TEST_CASE(tcs, new_userdata); + ATF_ADD_TEST_CASE(tcs, next__empty); + ATF_ADD_TEST_CASE(tcs, next__many); + ATF_ADD_TEST_CASE(tcs, open_base); + ATF_ADD_TEST_CASE(tcs, open_string); + ATF_ADD_TEST_CASE(tcs, open_table); + ATF_ADD_TEST_CASE(tcs, pcall__ok); + ATF_ADD_TEST_CASE(tcs, pcall__fail); + ATF_ADD_TEST_CASE(tcs, pop__one); + ATF_ADD_TEST_CASE(tcs, pop__many); + ATF_ADD_TEST_CASE(tcs, push_boolean); + ATF_ADD_TEST_CASE(tcs, push_c_closure); + ATF_ADD_TEST_CASE(tcs, push_c_function__c_ok); + ATF_ADD_TEST_CASE(tcs, push_c_function__cxx_ok); + ATF_ADD_TEST_CASE(tcs, push_c_function__cxx_fail_exception); + ATF_ADD_TEST_CASE(tcs, push_c_function__cxx_fail_anything); + ATF_ADD_TEST_CASE(tcs, push_c_function__cxx_fail_overflow); + ATF_ADD_TEST_CASE(tcs, push_integer); + ATF_ADD_TEST_CASE(tcs, push_nil); + ATF_ADD_TEST_CASE(tcs, push_string); + ATF_ADD_TEST_CASE(tcs, set_global__ok); + ATF_ADD_TEST_CASE(tcs, set_global__fail); + ATF_ADD_TEST_CASE(tcs, set_metatable__top); + ATF_ADD_TEST_CASE(tcs, set_metatable__explicit); + ATF_ADD_TEST_CASE(tcs, set_table__ok); + ATF_ADD_TEST_CASE(tcs, set_table__nil); + ATF_ADD_TEST_CASE(tcs, to_boolean__top); + ATF_ADD_TEST_CASE(tcs, to_boolean__explicit); + ATF_ADD_TEST_CASE(tcs, to_integer__top); + ATF_ADD_TEST_CASE(tcs, to_integer__explicit); + ATF_ADD_TEST_CASE(tcs, to_string__top); + ATF_ADD_TEST_CASE(tcs, to_string__explicit); + ATF_ADD_TEST_CASE(tcs, to_userdata__top); + ATF_ADD_TEST_CASE(tcs, to_userdata__explicit); + ATF_ADD_TEST_CASE(tcs, upvalue_index); } diff --git a/test_utils.hpp b/test_utils.hpp index 1241c7d..2bb761e 100644 --- a/test_utils.hpp +++ b/test_utils.hpp @@ -42,7 +42,7 @@ #include #include "exceptions.hpp" -#include "wrap.hpp" +#include "state.hpp" namespace {