sol2/tests/runtime_tests/source/operators.cpp

// sol3

// The MIT License (MIT)

// Copyright (c) 2013-2019 Rapptz, ThePhD and contributors

// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#include "sol_test.hpp"

#include <catch.hpp>

#include <algorithm>
#include <numeric>
#include <iostream>

struct T {};

TEST_CASE("operators/default", "test that generic equality operators and all sorts of equality tests can be used") {
	struct U {
		int a;
		U(int x = 20) : a(x) {
		}
		bool operator==(const U& r) {
			return a == r.a;
		}
	};
	struct V {
		int a;
		V(int x = 20) : a(x) {
		}
		bool operator==(const V& r) const {
			return a == r.a;
		}
	};

	sol::state lua;
	lua.open_libraries(sol::lib::base);

	T t1;
	T& t2 = t1;
	T t3;
	U u1;
	U u2{ 30 };
	U u3;
	V v1;
	V v2{ 30 };
	V v3;
	lua["t1"] = &t1;
	lua["t2"] = &t2;
	lua["t3"] = &t3;
	lua["u1"] = &u1;
	lua["u2"] = &u2;
	lua["u3"] = &u3;
	lua["v1"] = &v1;
	lua["v2"] = &v2;
	lua["v3"] = &v3;

	SECTION("plain") {
		// Can only compare identity here
		{
			auto result1 = lua.safe_script(
				"assert(t1 == t1)"
				"assert(t2 == t2)"
				"assert(t3 == t3)",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		{
			auto result1 = lua.safe_script(
				"assert(t1 == t2)"
				"assert(not (t1 == t3))"
				"assert(not (t2 == t3))",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		// Object should compare equal to themselves
		// (and not invoke operator==; pointer test should be sufficient)
		{
			auto result1 = lua.safe_script(
				"assert(u1 == u1)"
				"assert(u2 == u2)"
				"assert(u3 == u3)",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		{
			auto result1 = lua.safe_script(
				"assert(not (u1 == u2))"
				"assert(u1 == u3)"
				"assert(not (u2 == u3))",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		// Object should compare equal to themselves
		// (and not invoke operator==; pointer test should be sufficient)
		{
			auto result1 = lua.safe_script(
				"assert(v1 == v1)"
				"assert(v2 == v2)"
				"assert(v3 == v3)",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		{
			auto result1 = lua.safe_script(
				"assert(not (v1 == v2))"
				"assert(v1 == v3)"
				"assert(not (v2 == v3))",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
	}
	SECTION("regular") {
		lua.new_usertype<T>("T");
		lua.new_usertype<U>("U");
		lua.new_usertype<V>("V");

		// Can only compare identity here
		{
			auto result1 = lua.safe_script(
				"assert(t1 == t1)"
				"assert(t2 == t2)"
				"assert(t3 == t3)",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		{
			auto result1 = lua.safe_script(
				"assert(t1 == t2)"
				"assert(not (t1 == t3))"
				"assert(not (t2 == t3))",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		// Object should compare equal to themselves
		// (and not invoke operator==; pointer test should be sufficient)
		{
			auto result1 = lua.safe_script(
				"assert(u1 == u1)"
				"assert(u2 == u2)"
				"assert(u3 == u3)",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		{
			auto result1 = lua.safe_script(
				"assert(not (u1 == u2))"
				"assert(u1 == u3)"
				"assert(not (u2 == u3))",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		// Object should compare equal to themselves
		// (and not invoke operator==; pointer test should be sufficient)
		{
			auto result1 = lua.safe_script(
				"assert(v1 == v1)"
				"assert(v2 == v2)"
				"assert(v3 == v3)",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
		{
			auto result1 = lua.safe_script(
				"assert(not (v1 == v2))"
				"assert(v1 == v3)"
				"assert(not (v2 == v3))",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
		}
	}
}

TEST_CASE("operators/default with pointers", "test that default operations still work when working with reference (pointer) types") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<T>("T");


	T test;

	lua["t1"] = &test;
	lua["t2"] = &test;
	lua["t3"] = std::unique_ptr<T, no_delete>(&test);
	lua["t4"] = std::unique_ptr<T, no_delete>(&test);

	lua.script("ptr_test = t1 == t2");
	lua.script("unique_test = t3 == t4");

	bool ptr_test = lua["ptr_test"];
	bool unique_test = lua["unique_test"];
	REQUIRE(ptr_test);
	REQUIRE(unique_test);

#if SOL_LUA_VERSION > 502
	lua.script("ptr_unique_test = t1 == t3");

	bool ptr_unique_test = lua["ptr_unique_test"];
	REQUIRE(ptr_unique_test);
#endif
}

TEST_CASE("operators/call", "test call operator generation") {
	struct callable {
		int operator()(int a, std::string b) {
			return a + static_cast<int>(b.length());
		}
	};

	sol::state lua;
	lua.open_libraries(sol::lib::base);

	SECTION("plain") {
		{
			lua.set("obj", callable());
			auto result1 = lua.safe_script("v = obj(2, 'bark woof')", sol::script_pass_on_error);
			REQUIRE(result1.valid());
			int v = lua["v"];
			REQUIRE(v == 11);
		}
	}
	SECTION("regular") {
		lua.new_usertype<callable>("callable");
		{
			auto result1 = lua.safe_script(
				"obj = callable.new()\n"
				"v = obj(2, 'bark woof')",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
			int v = lua["v"];
			REQUIRE(v == 11);
		}
	}
}

struct stringable {
	static const void* last_print_ptr;
};
const void* stringable::last_print_ptr = nullptr;

std::ostream& operator<<(std::ostream& ostr, const stringable& o) {
	stringable::last_print_ptr = static_cast<const void*>(&o);
	return ostr << "{ stringable, std::ostream! }";
}

struct adl_stringable {
	static const void* last_print_ptr;
};
const void* adl_stringable::last_print_ptr = nullptr;

std::string to_string(const adl_stringable& o) {
	adl_stringable::last_print_ptr = static_cast<const void*>(&o);
	return "{ adl_stringable, to_string! }";
}

namespace inside {
	struct adl_stringable2 {
		static const void* last_print_ptr;
	};
	const void* adl_stringable2::last_print_ptr = nullptr;

	std::string to_string(const adl_stringable2& o) {
		adl_stringable2::last_print_ptr = static_cast<const void*>(&o);
		return "{ inside::adl_stringable2, inside::to_string! }";
	}
} // namespace inside

struct member_stringable {
	static const void* last_print_ptr;

	std::string to_string() const {
		member_stringable::last_print_ptr = static_cast<const void*>(this);
		return "{ member_stringable, to_string! }";
	}
};
const void* member_stringable::last_print_ptr = nullptr;

TEST_CASE("operators/stringable", "test std::ostream stringability") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	SECTION("plain") {
		{
			lua["obj"] = stringable();
			auto result1 = lua.safe_script("print(obj)", sol::script_pass_on_error);
			REQUIRE(result1.valid());
			stringable& obj = lua["obj"];
			REQUIRE(stringable::last_print_ptr == &obj);
		}
	}
	SECTION("regular") {
		lua.new_usertype<stringable>("stringable");
		{
			auto result1 = lua.safe_script(R"(obj = stringable.new()
				print(obj) )",
				sol::script_pass_on_error);
			REQUIRE(result1.valid());
			stringable& obj = lua["obj"];
			REQUIRE(stringable::last_print_ptr == &obj);
		}
	}
}

TEST_CASE("operators/adl_stringable", "test adl to_string stringability") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	SECTION("plain") {
		{
			lua["obj"] = adl_stringable();
			lua.safe_script("print(obj)");
			adl_stringable& obj = lua["obj"];
			REQUIRE(adl_stringable::last_print_ptr == &obj);
		}
	}
	SECTION("regular") {
		lua.new_usertype<adl_stringable>("stringable");
		{
			lua["obj"] = adl_stringable();
			lua.safe_script("print(obj)");
			adl_stringable& obj = lua["obj"];
			REQUIRE(adl_stringable::last_print_ptr == &obj);
		}
	}
}

TEST_CASE("operators/inside::adl_stringable2", "test adl to_string stringability from inside a namespace") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	SECTION("plain") {
		{
			lua["obj"] = inside::adl_stringable2();
			lua.safe_script("print(obj)");
			inside::adl_stringable2& obj = lua["obj"];
			REQUIRE(inside::adl_stringable2::last_print_ptr == &obj);
		}
	}
	SECTION("regular") {
		lua.new_usertype<inside::adl_stringable2>("stringable");
		{
			lua.safe_script("obj = stringable.new()");
			lua.safe_script("print(obj)");
			inside::adl_stringable2& obj = lua["obj"];
			REQUIRE(inside::adl_stringable2::last_print_ptr == &obj);
		}
	}
}

TEST_CASE("operators/member_stringable", "test member to_string stringability") {
	sol::state lua;
	lua.open_libraries(sol::lib::base);

	SECTION("plain") {
		{
			lua["obj"] = member_stringable();
			lua.safe_script("print(obj)");
			member_stringable& obj = lua["obj"];
			REQUIRE(member_stringable::last_print_ptr == &obj);
		}
	}
	SECTION("regular") {
		lua.new_usertype<member_stringable>("stringable");
		{
			lua.safe_script("obj = stringable.new()");
			lua.safe_script("print(obj)");
			member_stringable& obj = lua["obj"];
			REQUIRE(member_stringable::last_print_ptr == &obj);
		}
	}
}

TEST_CASE("operators/container-like", "test that generic begin/end and iterator are automatically bound") {
#if SOL_LUA_VERSION > 501
	struct container {
		typedef int* iterator;
		typedef int value_type;

		value_type values[10];

		container() {
			std::iota(begin(), end(), 1);
		}

		iterator begin() {
			return &values[0];
		}

		iterator end() {
			return &values[0] + 10;
		}
	};

	sol::state lua;
	lua.open_libraries(sol::lib::base);

	SECTION("plain") {
		{
			lua["obj"] = container();
			lua.safe_script("i = 0 for k, v in pairs(obj) do i = i + 1 assert(k == v) end");
			std::size_t i = lua["i"];
			REQUIRE(i == 10);
		}
	}
	SECTION("regular") {
		lua.new_usertype<container>("container");
		{
			lua.safe_script("obj = container.new()");
			lua.safe_script("i = 0 for k, v in pairs(obj) do i = i + 1 assert(k == v) end");
			std::size_t i = lua["i"];
			REQUIRE(i == 10);
		}
	}
#else
	SUCCEED("");
#endif
}

TEST_CASE("operators/length", "test that size is automatically bound to the length operator") {
	struct sizable {
		std::size_t size() const {
			return 6;
		}
	};

	sol::state lua;
	lua.open_libraries(sol::lib::base);

	SECTION("plain") {
		{
			lua["obj"] = sizable();
			lua.safe_script("s = #obj");
			std::size_t s = lua["s"];
			REQUIRE(s == 6);
		}
	}
	SECTION("regular") {
		lua.new_usertype<sizable>("sizable");
		{
			lua.safe_script("obj = sizable.new()");
			lua.safe_script("s = #obj");
			std::size_t s = lua["s"];
			REQUIRE(s == 6);
		}
	}
}