sol2/test_usertypes.cpp

#define SOL_CHECK_ARGUMENTS

#include <sol.hpp>
#include <catch.hpp>

#include <iostream>

struct vars {
	vars() {

	}

	int boop = 0;

	~vars() {

	}
};

struct fuser {
	int x;
	fuser() : x(0) {}

	fuser(int x) : x(x) {}

	int add(int y) {
		return x + y;
	}

	int add2(int y) {
		return x + y + 2;
	}
};

namespace crapola {
	struct fuser {
		int x;
		fuser() : x(0) {}
		fuser(int x) : x(x) {}
		fuser(int x, int x2) : x(x * x2) {}

		int add(int y) {
			return x + y;
		}
		int add2(int y) {
			return x + y + 2;
		}
	};
} // crapola

class Base {
public:
	Base(int a_num) : m_num(a_num) { }

	int get_num() {
		return m_num;
	}

protected:
	int m_num;
};

class Derived : public Base {
public:
	Derived(int a_num) : Base(a_num) { }

	int get_num_10() {
		return 10 * m_num;
	}
};

struct Vec {
	float x, y, z;
	Vec(float x, float y, float z) : x{ x }, y{ y }, z{ z } {}
	float length() {
		return sqrtf(x*x + y*y + z*z);
	}
	Vec normalized() {
		float invS = 1 / length();
		return{ x * invS, y * invS, z * invS };
	}
};

struct giver {
	int a = 0;

	giver() {

	}

	void gief() {
		a = 1;
	}

	static void stuff() {

	}

	static void gief_stuff(giver& t, int a) {
		t.a = a;
	}

	~giver() {

	}

};

struct factory_test {
private:
	factory_test() { a = true_a; }
	~factory_test() { a = 0; }
public:
	static int num_saved;
	static int num_killed;

	struct deleter {
		void operator()(factory_test* f) {
			f->~factory_test();
		}
	};

	static const int true_a;
	int a;

	static std::unique_ptr<factory_test, deleter> make() {
		return std::unique_ptr<factory_test, deleter>(new factory_test(), deleter());
	}

	static void save(factory_test& f) {
		new(&f)factory_test();
		++num_saved;
	}

	static void kill(factory_test& f) {
		f.~factory_test();
		++num_killed;
	}
};

int factory_test::num_saved = 0;
int factory_test::num_killed = 0;
const int factory_test::true_a = 156;

bool something() {
	return true;
}

struct thing {
	int v = 100;

	thing() {}
	thing(int x) : v(x) {}
};

struct self_test {
	int bark;

	self_test() : bark(100) {

	}

	void g(const std::string& str) {
		std::cout << str << '\n';
		bark += 1;
	}

	void f(const self_test& t) {
		std::cout << "got test" << '\n';
		if (t.bark != bark)
			throw sol::error("bark values are not the same for self_test f function");
		if (&t != this)
			throw sol::error("call does not reference self for self_test f function");
	}
};



TEST_CASE("usertype/usertype", "Show that we can create classes from usertype and use them") {
	sol::state lua;

	sol::usertype<fuser> lc{ "add", &fuser::add, "add2", &fuser::add2 };
	lua.set_usertype(lc);

	lua.script("a = fuser:new()\n"
		"b = a:add(1)\n"
		"c = a:add2(1)\n");

	sol::object a = lua.get<sol::object>("a");
	sol::object b = lua.get<sol::object>("b");
	sol::object c = lua.get<sol::object>("c");
	REQUIRE((a.is<sol::userdata_value>()));
	auto atype = a.get_type();
	auto btype = b.get_type();
	auto ctype = c.get_type();
	REQUIRE((atype == sol::type::userdata));
	REQUIRE((btype == sol::type::number));
	REQUIRE((ctype == sol::type::number));
	int bresult = b.as<int>();
	int cresult = c.as<int>();
	REQUIRE(bresult == 1);
	REQUIRE(cresult == 3);
}

TEST_CASE("usertype/usertype-constructors", "Show that we can create classes from usertype and use them with multiple constructors") {

	sol::state lua;

	sol::constructors<sol::types<>, sol::types<int>, sol::types<int, int>> con;
	sol::usertype<crapola::fuser> lc(con, "add", &crapola::fuser::add, "add2", &crapola::fuser::add2);
	lua.set_usertype(lc);

	lua.script(
		"a = fuser.new(2)\n"
		"u = a:add(1)\n"
		"v = a:add2(1)\n"
		"b = fuser:new()\n"
		"w = b:add(1)\n"
		"x = b:add2(1)\n"
		"c = fuser.new(2, 3)\n"
		"y = c:add(1)\n"
		"z = c:add2(1)\n");
	sol::object a = lua.get<sol::object>("a");
	auto atype = a.get_type();
	REQUIRE((atype == sol::type::userdata));
	sol::object u = lua.get<sol::object>("u");
	sol::object v = lua.get<sol::object>("v");
	REQUIRE((u.as<int>() == 3));
	REQUIRE((v.as<int>() == 5));

	sol::object b = lua.get<sol::object>("b");
	auto btype = b.get_type();
	REQUIRE((btype == sol::type::userdata));
	sol::object w = lua.get<sol::object>("w");
	sol::object x = lua.get<sol::object>("x");
	REQUIRE((w.as<int>() == 1));
	REQUIRE((x.as<int>() == 3));

	sol::object c = lua.get<sol::object>("c");
	auto ctype = c.get_type();
	REQUIRE((ctype == sol::type::userdata));
	sol::object y = lua.get<sol::object>("y");
	sol::object z = lua.get<sol::object>("z");
	REQUIRE((y.as<int>() == 7));
	REQUIRE((z.as<int>() == 9));
}

TEST_CASE("usertype/usertype-utility", "Show internal management of classes registered through new_usertype") {
	sol::state lua;

	lua.new_usertype<fuser>("fuser", "add", &fuser::add, "add2", &fuser::add2);

	lua.script("a = fuser.new()\n"
		"b = a:add(1)\n"
		"c = a:add2(1)\n");

	sol::object a = lua.get<sol::object>("a");
	sol::object b = lua.get<sol::object>("b");
	sol::object c = lua.get<sol::object>("c");
	REQUIRE((a.is<sol::userdata_value>()));
	auto atype = a.get_type();
	auto btype = b.get_type();
	auto ctype = c.get_type();
	REQUIRE((atype == sol::type::userdata));
	REQUIRE((btype == sol::type::number));
	REQUIRE((ctype == sol::type::number));
	int bresult = b.as<int>();
	int cresult = c.as<int>();
	REQUIRE(bresult == 1);
	REQUIRE(cresult == 3);
}

TEST_CASE("usertype/usertype-utility-derived", "usertype classes must play nice when a derived class does not overload a publically visible base function") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);
	sol::constructors<sol::types<int>> basector;
	sol::usertype<Base> baseusertype(basector, "get_num", &Base::get_num);

	lua.set_usertype(baseusertype);

	lua.script("base = Base.new(5)");
	REQUIRE_NOTHROW(lua.script("print(base:get_num())"));

	sol::constructors<sol::types<int>> derivedctor;
	sol::usertype<Derived> derivedusertype(derivedctor,
		"get_num_10", &Derived::get_num_10,
		"get_num", &Derived::get_num
	);

	lua.set_usertype(derivedusertype);

	lua.script("derived = Derived.new(7)");
	Derived& derived = lua["derived"];
	lua.script("dgn = derived:get_num()\n"
		"print(dgn)");
	lua.script("dgn10 = derived:get_num_10()\n"
		"print(dgn10)");

	REQUIRE((lua.get<int>("dgn10") == 70));
	REQUIRE((lua.get<int>("dgn") == 7));
}

TEST_CASE("usertype/self-referential usertype", "usertype classes must play nice when C++ object types are requested for C++ code") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<self_test>("test", "g", &self_test::g, "f", &self_test::f);

	lua.script(
		"local a = test.new()\n"
		"a:g(\"woof\")\n"
		"a:f(a)\n"
	);
}

TEST_CASE("usertype/issue-number-twenty-five", "Using pointers and references from C++ classes in Lua") {
	struct test {
		int x = 0;
		test& set() {
			x = 10;
			return *this;
		}

		int get() {
			return x;
		}

		test* pget() {
			return this;
		}

		test create_get() {
			return *this;
		}

		int fun(int xa) {
			return xa * 10;
		}
	};

	sol::state lua;
	lua.open_libraries(sol::lib::base);
	lua.new_usertype<test>("test", "set", &test::set, "get", &test::get, "pointer_get", &test::pget, "fun", &test::fun, "create_get", &test::create_get);
	REQUIRE_NOTHROW(lua.script("x = test.new()"));
	REQUIRE_NOTHROW(lua.script("assert(x:set():get() == 10)"));
	REQUIRE_NOTHROW(lua.script("y = x:pointer_get()"));
	REQUIRE_NOTHROW(lua.script("y:set():get()"));
	REQUIRE_NOTHROW(lua.script("y:fun(10)"));
	REQUIRE_NOTHROW(lua.script("x:fun(10)"));
	REQUIRE_NOTHROW(lua.script("assert(y:fun(10) == x:fun(10), '...')"));
	REQUIRE_NOTHROW(lua.script("assert(y:fun(10) == 100, '...')"));
	REQUIRE_NOTHROW(lua.script("assert(y:set():get() == y:set():get(), '...')"));
	REQUIRE_NOTHROW(lua.script("assert(y:set():get() == 10, '...')"));
}

TEST_CASE("usertype/issue-number-thirty-five", "using value types created from lua-called C++ code, fixing user-defined types with constructors") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	sol::constructors<sol::types<float, float, float>> ctor;
	sol::usertype<Vec> udata(ctor, "normalized", &Vec::normalized, "length", &Vec::length);
	lua.set_usertype(udata);

	REQUIRE_NOTHROW(lua.script("v = Vec.new(1, 2, 3)\n"
		"print(v:length())"));
	REQUIRE_NOTHROW(lua.script("v = Vec.new(1, 2, 3)\n"
		"print(v:normalized():length())"));
}

TEST_CASE("usertype/lua-stored-usertype", "ensure usertype values can be stored without keeping usertype object alive") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	{
		sol::constructors<sol::types<float, float, float>> ctor;
		sol::usertype<Vec> udata(ctor,
			"normalized", &Vec::normalized,
			"length", &Vec::length);

		lua.set_usertype(udata);
		// usertype dies, but still usable in lua!
	}

	REQUIRE_NOTHROW(lua.script("collectgarbage()\n"
		"v = Vec.new(1, 2, 3)\n"
		"print(v:length())"));

	REQUIRE_NOTHROW(lua.script("v = Vec.new(1, 2, 3)\n"
		"print(v:normalized():length())"));
}

TEST_CASE("usertype/member-variables", "allow table-like accessors to behave as member variables for usertype") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);
	sol::constructors<sol::types<float, float, float>> ctor;
	sol::usertype<Vec> udata(ctor,
		"x", &Vec::x,
		"y", &Vec::y,
		"z", &Vec::z,
		"normalized", &Vec::normalized,
		"length", &Vec::length);
	lua.set_usertype(udata);

	REQUIRE_NOTHROW(lua.script("v = Vec.new(1, 2, 3)\n"
		"v2 = Vec.new(0, 1, 0)\n"
		"print(v:length())\n"
	));
	REQUIRE_NOTHROW(lua.script("v.x = 2\n"
		"v2.y = 2\n"
		"print(v.x, v.y, v.z)\n"
		"print(v2.x, v2.y, v2.z)\n"
	));
	REQUIRE_NOTHROW(lua.script("assert(v.x == 2)\n"
		"assert(v2.x == 0)\n"
		"assert(v2.y == 2)\n"
	));
	REQUIRE_NOTHROW(lua.script("v.x = 3\n"
		"local x = v.x\n"
		"assert(x == 3)\n"
	));

	struct breaks {
		sol::function f;
	};

	lua.open_libraries(sol::lib::base);
	lua.set("b", breaks());
	lua.new_usertype<breaks>("breaks",
		"f", &breaks::f
		);

	breaks& b = lua["b"];
	REQUIRE_NOTHROW(lua.script("b.f = function () print('BARK!') end"));
	REQUIRE_NOTHROW(lua.script("b.f()"));
	REQUIRE_NOTHROW(b.f());
}

TEST_CASE("usertype/nonmember-functions", "let users set non-member functions that take unqualified T as first parameter to usertype") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<giver>("giver",
		"gief_stuff", giver::gief_stuff,
		"gief", &giver::gief,
		"__tostring", [](const giver& t) {
		return std::to_string(t.a) + ": giving value";
	}
		).get<sol::table>("giver")
		.set_function("stuff", giver::stuff);

	REQUIRE_NOTHROW(lua.script("giver.stuff()"));
	REQUIRE_NOTHROW(lua.script("t = giver.new()\n"
		"print(tostring(t))\n"
		"t:gief()\n"
		"t:gief_stuff(20)\n"));
	REQUIRE((lua.get<giver>("t").a == 20));
}

TEST_CASE("usertype/unique-shared-ptr", "manage the conversion and use of unique and shared pointers ('unique usertypes')") {
	const int64_t unique_value = 0x7125679355635963;
	auto uniqueint = std::make_unique<int64_t>(unique_value);
	auto sharedint = std::make_shared<int64_t>(unique_value);
	long preusecount = sharedint.use_count();
	{ sol::state lua;
	lua.open_libraries(sol::lib::base);
	lua.set("uniqueint", std::move(uniqueint));
	lua.set("sharedint", sharedint);
	std::unique_ptr<int64_t>& uniqueintref = lua["uniqueint"];
	std::shared_ptr<int64_t>& sharedintref = lua["sharedint"];
	int64_t* rawuniqueintref = lua["uniqueint"];
	int64_t* rawsharedintref = lua["sharedint"];
	int siusecount = sharedintref.use_count();
	REQUIRE((uniqueintref.get() == rawuniqueintref && sharedintref.get() == rawsharedintref));
	REQUIRE((uniqueintref != nullptr && sharedintref != nullptr && rawuniqueintref != nullptr && rawsharedintref != nullptr));
	REQUIRE((unique_value == *uniqueintref.get() && unique_value == *sharedintref.get()));
	REQUIRE((unique_value == *rawuniqueintref && unique_value == *rawsharedintref));
	REQUIRE(siusecount == sharedint.use_count());
	std::shared_ptr<int64_t> moreref = sharedint;
	REQUIRE(unique_value == *moreref.get());
	REQUIRE(moreref.use_count() == sharedint.use_count());
	REQUIRE(moreref.use_count() == sharedintref.use_count());
	}
	REQUIRE(preusecount == sharedint.use_count());
}

TEST_CASE("regressions/one", "issue number 48") {
	sol::state lua;
	lua.new_usertype<vars>("vars",
		"boop", &vars::boop);
	REQUIRE_NOTHROW(lua.script("beep = vars.new()\n"
		"beep.boop = 1"));
	// test for segfault
	auto my_var = lua.get<vars>("beep");
	REQUIRE(my_var.boop == 1);
	auto* ptr = &my_var;
	REQUIRE(ptr->boop == 1);
}

TEST_CASE("usertype/get-set-references", "properly get and set with std::ref semantics. Note that to get, we must not use Unqualified<T> on the type...") {
	sol::state lua;

	lua.new_usertype<vars>("vars",
		"boop", &vars::boop);
	vars var{};
	vars rvar{};
	lua.set("beep", var);
	lua.set("rbeep", std::ref(rvar));
	auto& my_var = lua.get<vars>("beep");
	auto& ref_var = lua.get<std::reference_wrapper<vars>>("rbeep");
	vars& proxy_my_var = lua["beep"];
	std::reference_wrapper<vars> proxy_ref_var = lua["rbeep"];
	var.boop = 2;
	rvar.boop = 5;

	// Was return as a value: var must be diferent from "beep"
	REQUIRE_FALSE(std::addressof(var) == std::addressof(my_var));
	REQUIRE_FALSE(std::addressof(proxy_my_var) == std::addressof(var));
	REQUIRE((my_var.boop == 0));
	REQUIRE(var.boop != my_var.boop);

	REQUIRE(std::addressof(ref_var) == std::addressof(rvar));
	REQUIRE(std::addressof(proxy_ref_var.get()) == std::addressof(rvar));
	REQUIRE(rvar.boop == 5);
	REQUIRE(rvar.boop == ref_var.boop);
}

TEST_CASE("usertype/destructor-tests", "Show that proper copies / destruction happens") {
	static int created = 0;
	static int destroyed = 0;
	static void* last_call = nullptr;
	struct x {
		x() { ++created; }
		x(const x&) { ++created; }
		x(x&&) { ++created; }
		x& operator=(const x&) { return *this; }
		x& operator=(x&&) { return *this; }
		~x() { ++destroyed; }
	};
	{
		sol::state lua;
		lua.new_usertype<x>("x");
		x x1;
		x x2;
		lua.set("x1copy", x1, "x2copy", x2, "x1ref", std::ref(x1));
		x& x1copyref = lua["x1copy"];
		x& x2copyref = lua["x2copy"];
		x& x1ref = lua["x1ref"];
		REQUIRE(created == 4);
		REQUIRE(destroyed == 0);
		REQUIRE(std::addressof(x1) == std::addressof(x1ref));
	}
	REQUIRE(created == 4);
	REQUIRE(destroyed == 4);
}

TEST_CASE("usertype/private-constructible", "Check to make sure special snowflake types from Enterprise thingamahjongs work properly.") {
	int numsaved = factory_test::num_saved;
	int numkilled = factory_test::num_killed;
	{
		sol::state lua;
		lua.open_libraries(sol::lib::base);

		lua.new_usertype<factory_test>("factory_test",
			"new", sol::initializers(factory_test::save),
			"__gc", sol::destructor(factory_test::kill),
			"a", &factory_test::a
			);

		std::unique_ptr<factory_test, factory_test::deleter> f = factory_test::make();
		lua.set("true_a", factory_test::true_a, "f", f.get());
		REQUIRE_NOTHROW(lua.script("assert(f.a == true_a)"));

		REQUIRE_NOTHROW(lua.script(
			"local fresh_f = factory_test:new()\n"
			"assert(fresh_f.a == true_a)\n"));
	}
	int expectednumsaved = numsaved + 1;
	int expectednumkilled = numkilled + 1;
	REQUIRE(expectednumsaved == factory_test::num_saved);
	REQUIRE(expectednumkilled == factory_test::num_killed);
}

TEST_CASE("usertype/overloading", "Check if overloading works properly for usertypes") {
	struct woof {
		int var;

		int func(int x) {
			return var + x;
		}

		double func2(int x, int y) {
			return var + x + y + 0.5;
		}

		std::string func2s(int x, std::string y) {
			return y + " " + std::to_string(x);
		}
	};
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<woof>("woof",
		"var", &woof::var,
		"func", sol::overload(&woof::func, &woof::func2, &woof::func2s)
		);

	const std::string bark_58 = "bark 58";

	REQUIRE_NOTHROW(lua.script(
		"r = woof:new()\n"
		"a = r:func(1)\n"
		"b = r:func(1, 2)\n"
		"c = r:func(58, 'bark')\n"
	));
	REQUIRE((lua["a"] == 1));
	REQUIRE((lua["b"] == 3.5));
	REQUIRE((lua["c"] == bark_58));

	REQUIRE_THROWS(lua.script("r:func(1,2,'meow')"));
}

TEST_CASE("usertype/reference-and-constness", "Make sure constness compiles properly and errors out at runtime") {
	struct bark {
		int var = 50;
	};
	struct woof {
		bark b;
	};

	struct nested {
		const int f = 25;
	};

	struct outer {
		nested n;
	};

	bool caughterror = false;
	std::string msg;
	sol::state lua;
	lua.new_usertype<woof>("woof",
		"b", &woof::b);
	lua.new_usertype<bark>("bark",
		"var", &bark::var);
	lua.new_usertype<outer>("outer",
		"n", &outer::n);
	lua.set("w", woof());
	lua.set("n", nested());
	lua.set("o", outer());
	lua.set("f", sol::c_call<decltype(&nested::f), &nested::f>);
	lua.script(R"(
    x = w.b
    x.var = 20
    val = w.b.var == x.var
    v = f(n);
    )");

	woof& w = lua["w"];
	bark& x = lua["x"];
	nested& n = lua["n"];
	int v = lua["v"];
	bool val = lua["val"];
	// enforce reference semantics
	REQUIRE(std::addressof(w.b) == std::addressof(x));
	REQUIRE(n.f == 25);
	REQUIRE(v == 25);
	REQUIRE(val);

	REQUIRE_THROWS(lua.script("f(n, 50)"));
	REQUIRE_THROWS(lua.script("o.n = 25"));
}

TEST_CASE("usertype/readonly-and-static-functions", "Check if static functions can be called on userdata and from their originating (meta)tables") {
	struct bark {
		int var = 50;

		void func() {}

		static void oh_boy() {}

		static int oh_boy(std::string name) {
			return static_cast<int>(name.length());
		}

		int operator()(int x) {
			return x;
		}
	};

	sol::state lua;
	lua.open_libraries(sol::lib::base);
	lua.new_usertype<bark>("bark",
		"var", &bark::var,
		"var2", sol::readonly(&bark::var),
		"something", something,
		"something2", [](int x, int y) { return x + y; },
		"func", &bark::func,
		"oh_boy", sol::overload(sol::resolve<void()>(&bark::oh_boy), sol::resolve<int(std::string)>(&bark::oh_boy)),
		sol::meta_function::call_function, &bark::operator()
		);

	REQUIRE_NOTHROW(lua.script("assert(bark.oh_boy('woo') == 3)"));
	REQUIRE_NOTHROW(lua.script("bark.oh_boy()"));

	bark b;
	lua.set("b", &b);

	sol::table b_table = lua["b"];
	sol::function member_func = b_table["func"];
	sol::function s = b_table["something"];
	sol::function s2 = b_table["something2"];

	sol::table b_metatable = b_table[sol::metatable_key];
	bool isvalidmt = b_metatable.valid();
	REQUIRE(isvalidmt);
	sol::function b_call = b_metatable["__call"];
	sol::function b_as_function = lua["b"];

	int x = b_as_function(1);
	int y = b_call(b, 1);
	bool z = s();
	int w = s2(2, 3);
	REQUIRE(x == 1);
	REQUIRE(y == 1);
	REQUIRE(z);
	REQUIRE(w == 5);

	lua.script(R"(
lx = b(1)
ly = getmetatable(b).__call(b, 1)
lz = b.something()
lz2 = bark.something()
lw = b.something2(2, 3)
lw2 = bark.something2(2, 3)
    )");

	int lx = lua["lx"];
	int ly = lua["ly"];
	bool lz = lua["lz"];
	int lw = lua["lw"];
	bool lz2 = lua["lz2"];
	int lw2 = lua["lw2"];
	REQUIRE(lx == 1);
	REQUIRE(ly == 1);
	REQUIRE(lz);
	REQUIRE(lz2);
	REQUIRE(lw == 5);
	REQUIRE(lw2 == 5);
	REQUIRE(lx == ly);
	REQUIRE(lz == lz2);
	REQUIRE(lw == lw2);

	REQUIRE_THROWS(lua.script("b.var2 = 2"));
}

TEST_CASE("usertype/properties", "Check if member properties/variables work") {
	struct bark {
		int var = 50;
		int var2 = 25;

		int get_var2() const {
			return var2;
		}

		int get_var3() {
			return var2;
		}

		void set_var2(int x) {
			var2 = x;
		}
	};

	sol::state lua;
	lua.open_libraries(sol::lib::base);
	lua.new_usertype<bark>("bark",
		"var", &bark::var,
		"var2", sol::readonly(&bark::var2),
		"a", sol::property(&bark::get_var2, &bark::set_var2),
		"b", sol::property(&bark::get_var2),
		"c", sol::property(&bark::get_var3),
		"d", sol::property(&bark::set_var2)
		);

	bark b;
	lua.set("b", &b);

	lua.script("b.a = 59");
	lua.script("var2_0 = b.a");
	lua.script("var2_1 = b.b");
	lua.script("b.d = 1568");
	lua.script("var2_2 = b.c");

	int var2_0 = lua["var2_0"];
	int var2_1 = lua["var2_1"];
	int var2_2 = lua["var2_2"];
	REQUIRE(var2_0 == 59);
	REQUIRE(var2_1 == 59);
	REQUIRE(var2_2 == 1568);

	REQUIRE_THROWS(lua.script("b.var2 = 24"));
	REQUIRE_THROWS(lua.script("r = b.d"));
	REQUIRE_THROWS(lua.script("r = b.d"));
	REQUIRE_THROWS(lua.script("b.b = 25"));
	REQUIRE_THROWS(lua.script("b.c = 11"));
}

TEST_CASE("usertype/safety", "crash with an exception -- not a segfault -- on bad userdata calls") {
	class Test {
	public:
		void sayHello() { std::cout << "Hey\n"; }
	};

	sol::state lua;
	lua.new_usertype<Test>("Test", "sayHello", &Test::sayHello);
	static const std::string code = R"(
        local t = Test.new()
        t:sayHello() --Works fine
        t.sayHello() --Uh oh.
    )";
	REQUIRE_THROWS(lua.script(code));
}

TEST_CASE("usertype/call_constructor", "make sure lua types can be constructed with function call constructors") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<thing>("thing",
		"v", &thing::v
		, sol::call_constructor, sol::constructors<sol::types<>, sol::types<int>>()
		);

	lua.script(R"(
t = thing(256)
)");

	thing& y = lua["t"];
	std::cout << y.v << std::endl;
	REQUIRE(y.v == 256);
}

TEST_CASE("usertype/blank_constructor", "make sure lua types cannot be constructed if a blank / empty constructor is provided") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<thing>("thing",
		"v", &thing::v
		, sol::call_constructor, sol::constructors<>()
		);

	REQUIRE_THROWS(lua.script("t = thing(256)"));
}


TEST_CASE("usertype/no_constructor", "make sure lua types cannot be constructed if a blank / empty constructor is provided") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<thing>("thing",
		"v", &thing::v
		, sol::call_constructor, sol::no_constructor
		);

	REQUIRE_THROWS(lua.script("t = thing.new()"));
}