godot/tests/core/object/test_object.h

/**************************************************************************/
/*  test_object.h                                                         */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* 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.                 */
/**************************************************************************/

#pragma once

#include "core/object/class_db.h"
#include "core/object/object.h"
#include "core/object/script_language.h"

#include "tests/test_macros.h"

#ifdef SANITIZERS_ENABLED
#ifdef __has_feature
#if __has_feature(address_sanitizer) || __has_feature(thread_sanitizer)
#define ASAN_OR_TSAN_ENABLED
#endif
#elif defined(__SANITIZE_ADDRESS__) || defined(__SANITIZE_THREAD__)
#define ASAN_OR_TSAN_ENABLED
#endif
#endif

// Declared in global namespace because of GDCLASS macro warning (Windows):
// "Unqualified friend declaration referring to type outside of the nearest enclosing namespace
// is a Microsoft extension; add a nested name specifier".
class _TestDerivedObject : public Object {
	GDCLASS(_TestDerivedObject, Object);

	int property_value;

protected:
	static void _bind_methods() {
		ClassDB::bind_method(D_METHOD("set_property", "property"), &_TestDerivedObject::set_property);
		ClassDB::bind_method(D_METHOD("get_property"), &_TestDerivedObject::get_property);
		ADD_PROPERTY(PropertyInfo(Variant::INT, "property"), "set_property", "get_property");
	}

public:
	void set_property(int value) { property_value = value; }
	int get_property() const { return property_value; }
};

namespace TestObject {

class _MockScriptInstance : public ScriptInstance {
	StringName property_name = "NO_NAME";
	Variant property_value;

public:
	bool set(const StringName &p_name, const Variant &p_value) override {
		property_name = p_name;
		property_value = p_value;
		return true;
	}
	bool get(const StringName &p_name, Variant &r_ret) const override {
		if (property_name == p_name) {
			r_ret = property_value;
			return true;
		}
		return false;
	}
	void get_property_list(List<PropertyInfo> *p_properties) const override {
	}
	Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid) const override {
		return Variant::PACKED_FLOAT32_ARRAY;
	}
	virtual void validate_property(PropertyInfo &p_property) const override {
	}
	bool property_can_revert(const StringName &p_name) const override {
		return false;
	}
	bool property_get_revert(const StringName &p_name, Variant &r_ret) const override {
		return false;
	}
	void get_method_list(List<MethodInfo> *p_list) const override {
	}
	bool has_method(const StringName &p_method) const override {
		return false;
	}
	int get_method_argument_count(const StringName &p_method, bool *r_is_valid = nullptr) const override {
		if (r_is_valid) {
			*r_is_valid = false;
		}
		return 0;
	}
	Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override {
		return Variant();
	}
	void notification(int p_notification, bool p_reversed = false) override {
	}
	Ref<Script> get_script() const override {
		return Ref<Script>();
	}
	const Variant get_rpc_config() const override {
		return Variant();
	}
	ScriptLanguage *get_language() override {
		return nullptr;
	}
};

TEST_CASE("[Object] Core getters") {
	Object object;

	CHECK_MESSAGE(
			object.is_class("Object"),
			"is_class() should return the expected value.");
	CHECK_MESSAGE(
			object.get_class() == "Object",
			"The returned class should match the expected value.");
	CHECK_MESSAGE(
			object.get_class_name() == "Object",
			"The returned class name should match the expected value.");
	CHECK_MESSAGE(
			object.get_class_static() == "Object",
			"The returned static class should match the expected value.");
	CHECK_MESSAGE(
			object.get_save_class() == "Object",
			"The returned save class should match the expected value.");
}

TEST_CASE("[Object] Metadata") {
	const String meta_path = "complex_metadata_path";
	Object object;

	object.set_meta(meta_path, Color(0, 1, 0));
	CHECK_MESSAGE(
			Color(object.get_meta(meta_path)).is_equal_approx(Color(0, 1, 0)),
			"The returned object metadata after setting should match the expected value.");

	List<StringName> meta_list;
	object.get_meta_list(&meta_list);
	CHECK_MESSAGE(
			meta_list.size() == 1,
			"The metadata list should only contain 1 item after adding one metadata item.");

	object.remove_meta(meta_path);
	// Also try removing nonexistent metadata (it should do nothing, without printing an error message).
	object.remove_meta("I don't exist");
	ERR_PRINT_OFF;
	CHECK_MESSAGE(
			object.get_meta(meta_path) == Variant(),
			"The returned object metadata after removing should match the expected value.");
	ERR_PRINT_ON;

	List<StringName> meta_list2;
	object.get_meta_list(&meta_list2);
	CHECK_MESSAGE(
			meta_list2.size() == 0,
			"The metadata list should contain 0 items after removing all metadata items.");

	Object other;
	object.set_meta("conflicting_meta", "string");
	object.set_meta("not_conflicting_meta", 123);
	other.set_meta("conflicting_meta", Color(0, 1, 0));
	other.set_meta("other_meta", "other");
	object.merge_meta_from(&other);

	CHECK_MESSAGE(
			Color(object.get_meta("conflicting_meta")).is_equal_approx(Color(0, 1, 0)),
			"String meta should be overwritten with Color after merging.");

	CHECK_MESSAGE(
			int(object.get_meta("not_conflicting_meta")) == 123,
			"Not conflicting meta on destination should be kept intact.");

	CHECK_MESSAGE(
			object.get_meta("other_meta", String()) == "other",
			"Not conflicting meta name on source should merged.");

	List<StringName> meta_list3;
	object.get_meta_list(&meta_list3);
	CHECK_MESSAGE(
			meta_list3.size() == 3,
			"The metadata list should contain 3 items after merging meta from two objects.");
}

TEST_CASE("[Object] Construction") {
	Object object;

	CHECK_MESSAGE(
			!object.is_ref_counted(),
			"Object is not a RefCounted.");

	Object *p_db = ObjectDB::get_instance(object.get_instance_id());
	CHECK_MESSAGE(
			p_db == &object,
			"The database pointer returned by the object id should reference same object.");
}

TEST_CASE("[Object] Script instance property setter") {
	Object *object = memnew(Object);
	_MockScriptInstance *script_instance = memnew(_MockScriptInstance);
	object->set_script_instance(script_instance);

	bool valid = false;
	object->set("some_name", 100, &valid);
	CHECK(valid);
	Variant actual_value;
	CHECK_MESSAGE(
			script_instance->get("some_name", actual_value),
			"The assigned script instance should successfully retrieve value by name.");
	CHECK_MESSAGE(
			actual_value == Variant(100),
			"The returned value should equal the one which was set by the object.");
	memdelete(object);
}

TEST_CASE("[Object] Script instance property getter") {
	Object *object = memnew(Object);
	_MockScriptInstance *script_instance = memnew(_MockScriptInstance);
	script_instance->set("some_name", 100); // Make sure script instance has the property
	object->set_script_instance(script_instance);

	bool valid = false;
	const Variant &actual_value = object->get("some_name", &valid);
	CHECK(valid);
	CHECK_MESSAGE(
			actual_value == Variant(100),
			"The returned value should equal the one which was set by the script instance.");
	memdelete(object);
}

TEST_CASE("[Object] Built-in property setter") {
	GDREGISTER_CLASS(_TestDerivedObject);
	_TestDerivedObject derived_object;

	bool valid = false;
	derived_object.set("property", 100, &valid);
	CHECK(valid);
	CHECK_MESSAGE(
			derived_object.get_property() == 100,
			"The property value should equal the one which was set with built-in setter.");
}

TEST_CASE("[Object] Built-in property getter") {
	GDREGISTER_CLASS(_TestDerivedObject);
	_TestDerivedObject derived_object;
	derived_object.set_property(100);

	bool valid = false;
	const Variant &actual_value = derived_object.get("property", &valid);
	CHECK(valid);
	CHECK_MESSAGE(
			actual_value == Variant(100),
			"The returned value should equal the one which was set with built-in setter.");
}

TEST_CASE("[Object] Script property setter") {
	Object object;
	Variant script;

	bool valid = false;
	object.set(CoreStringName(script), script, &valid);
	CHECK(valid);
	CHECK_MESSAGE(
			object.get_script() == script,
			"The object script should be equal to the assigned one.");
}

TEST_CASE("[Object] Script property getter") {
	Object object;
	Variant script;
	object.set_script(script);

	bool valid = false;
	const Variant &actual_value = object.get(CoreStringName(script), &valid);
	CHECK(valid);
	CHECK_MESSAGE(
			actual_value == script,
			"The returned value should be equal to the assigned script.");
}

TEST_CASE("[Object] Absent name setter") {
	Object object;

	bool valid = true;
	object.set("absent_name", 100, &valid);
	CHECK(!valid);
}

TEST_CASE("[Object] Absent name getter") {
	Object object;

	bool valid = true;
	const Variant &actual_value = object.get("absent_name", &valid);
	CHECK(!valid);
	CHECK_MESSAGE(
			actual_value == Variant(),
			"The returned value should equal nil variant.");
}

class SignalReceiver : public Object {
	GDCLASS(SignalReceiver, Object);

public:
	Vector<Variant> received_args;

	void callback0() {
		received_args = Vector<Variant>{};
	}

	void callback1(Variant p_arg1) {
		received_args = Vector<Variant>{ p_arg1 };
	}

	void callback2(Variant p_arg1, Variant p_arg2) {
		received_args = Vector<Variant>{ p_arg1, p_arg2 };
	}

	void callback3(Variant p_arg1, Variant p_arg2, Variant p_arg3) {
		received_args = Vector<Variant>{ p_arg1, p_arg2, p_arg3 };
	}
};

TEST_CASE("[Object] Signals") {
	Object object;

	CHECK_FALSE(object.has_signal("my_custom_signal"));

	List<MethodInfo> signals_before;
	object.get_signal_list(&signals_before);

	object.add_user_signal(MethodInfo("my_custom_signal"));

	CHECK(object.has_signal("my_custom_signal"));

	List<MethodInfo> signals_after;
	object.get_signal_list(&signals_after);

	// Should be one more signal.
	CHECK_EQ(signals_before.size() + 1, signals_after.size());

	SUBCASE("Adding the same user signal again should not have any effect") {
		CHECK(object.has_signal("my_custom_signal"));
		ERR_PRINT_OFF;
		object.add_user_signal(MethodInfo("my_custom_signal"));
		ERR_PRINT_ON;
		CHECK(object.has_signal("my_custom_signal"));

		List<MethodInfo> signals_after_existing_added;
		object.get_signal_list(&signals_after_existing_added);

		CHECK_EQ(signals_after.size(), signals_after_existing_added.size());
	}

	SUBCASE("Trying to add a preexisting signal should not have any effect") {
		CHECK(object.has_signal("script_changed"));
		ERR_PRINT_OFF;
		object.add_user_signal(MethodInfo("script_changed"));
		ERR_PRINT_ON;
		CHECK(object.has_signal("script_changed"));

		List<MethodInfo> signals_after_existing_added;
		object.get_signal_list(&signals_after_existing_added);

		CHECK_EQ(signals_after.size(), signals_after_existing_added.size());
	}

	SUBCASE("Adding an empty signal should not have any effect") {
		CHECK_FALSE(object.has_signal(""));
		ERR_PRINT_OFF;
		object.add_user_signal(MethodInfo(""));
		ERR_PRINT_ON;
		CHECK_FALSE(object.has_signal(""));

		List<MethodInfo> signals_after_empty_added;
		object.get_signal_list(&signals_after_empty_added);

		CHECK_EQ(signals_after.size(), signals_after_empty_added.size());
	}

	SUBCASE("Deleting an object with connected signals should disconnect them") {
		List<Object::Connection> signal_connections;

		{
			Object target;
			target.add_user_signal(MethodInfo("my_custom_signal"));

			ERR_PRINT_OFF;
			target.connect("nonexistent_signal1", callable_mp(&object, &Object::notify_property_list_changed));
			target.connect("my_custom_signal", callable_mp(&object, &Object::notify_property_list_changed));
			target.connect("nonexistent_signal2", callable_mp(&object, &Object::notify_property_list_changed));
			ERR_PRINT_ON;

			signal_connections.clear();
			object.get_all_signal_connections(&signal_connections);
			CHECK(signal_connections.size() == 0);
			signal_connections.clear();
			object.get_signals_connected_to_this(&signal_connections);
			CHECK(signal_connections.size() == 1);

			ERR_PRINT_OFF;
			object.connect("nonexistent_signal1", callable_mp(&target, &Object::notify_property_list_changed));
			object.connect("my_custom_signal", callable_mp(&target, &Object::notify_property_list_changed));
			object.connect("nonexistent_signal2", callable_mp(&target, &Object::notify_property_list_changed));
			ERR_PRINT_ON;

			signal_connections.clear();
			object.get_all_signal_connections(&signal_connections);
			CHECK(signal_connections.size() == 1);
			signal_connections.clear();
			object.get_signals_connected_to_this(&signal_connections);
			CHECK(signal_connections.size() == 1);
		}

		signal_connections.clear();
		object.get_all_signal_connections(&signal_connections);
		CHECK(signal_connections.size() == 0);
		signal_connections.clear();
		object.get_signals_connected_to_this(&signal_connections);
		CHECK(signal_connections.size() == 0);
	}

	SUBCASE("Emitting a non existing signal will return an error") {
		Error err = object.emit_signal("some_signal");
		CHECK(err == ERR_UNAVAILABLE);
	}

	SUBCASE("Emitting an existing signal should call the connected method") {
		Array empty_signal_args = { {} };

		SIGNAL_WATCH(&object, "my_custom_signal");
		SIGNAL_CHECK_FALSE("my_custom_signal");

		Error err = object.emit_signal("my_custom_signal");
		CHECK(err == OK);

		SIGNAL_CHECK("my_custom_signal", empty_signal_args);
		SIGNAL_UNWATCH(&object, "my_custom_signal");
	}

	SUBCASE("Connecting and then disconnecting many signals should not leave anything behind") {
		List<Object::Connection> signal_connections;
		Object targets[100];

		for (int i = 0; i < 10; i++) {
			ERR_PRINT_OFF;
			for (Object &target : targets) {
				object.connect("my_custom_signal", callable_mp(&target, &Object::notify_property_list_changed));
			}
			ERR_PRINT_ON;
			signal_connections.clear();
			object.get_all_signal_connections(&signal_connections);
			CHECK(signal_connections.size() == 100);
		}

		for (Object &target : targets) {
			object.disconnect("my_custom_signal", callable_mp(&target, &Object::notify_property_list_changed));
		}
		signal_connections.clear();
		object.get_all_signal_connections(&signal_connections);
		CHECK(signal_connections.size() == 0);
	}

	SUBCASE("Connecting with CONNECT_APPEND_SOURCE_OBJECT flag") {
		SignalReceiver target;

		object.connect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback1), Object::CONNECT_APPEND_SOURCE_OBJECT);
		object.emit_signal("my_custom_signal");
		CHECK_EQ(target.received_args, Vector<Variant>{ &object });
		object.disconnect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback1));

		object.connect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback2), Object::CONNECT_APPEND_SOURCE_OBJECT);
		object.emit_signal("my_custom_signal", "emit_arg");
		CHECK_EQ(target.received_args, Vector<Variant>{ "emit_arg", &object });
		object.disconnect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback2));

		object.connect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback2).bind("bind_arg"), Object::CONNECT_APPEND_SOURCE_OBJECT);
		object.emit_signal("my_custom_signal");
		CHECK_EQ(target.received_args, Vector<Variant>{ &object, "bind_arg" });
		object.disconnect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback2));

		object.connect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback3).bind("bind_arg"), Object::CONNECT_APPEND_SOURCE_OBJECT);
		object.emit_signal("my_custom_signal", "emit_arg");
		CHECK_EQ(target.received_args, Vector<Variant>{ "emit_arg", &object, "bind_arg" });
		object.disconnect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback3));

		object.connect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback3).bind(&object), Object::CONNECT_APPEND_SOURCE_OBJECT);
		object.emit_signal("my_custom_signal", &object);
		CHECK_EQ(target.received_args, Vector<Variant>{ &object, &object, &object });
		object.disconnect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback3));

		// Source should be appended regardless of unbinding.
		object.connect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback1).unbind(1), Object::CONNECT_APPEND_SOURCE_OBJECT);
		object.emit_signal("my_custom_signal", "emit_arg");
		CHECK_EQ(target.received_args, Vector<Variant>{ &object });
		object.disconnect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback1));

		object.connect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback2).bind("bind_arg").unbind(1), Object::CONNECT_APPEND_SOURCE_OBJECT);
		object.emit_signal("my_custom_signal", "emit_arg");
		CHECK_EQ(target.received_args, Vector<Variant>{ &object, "bind_arg" });
		object.disconnect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback2));

		object.connect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback2).unbind(1).bind("bind_arg"), Object::CONNECT_APPEND_SOURCE_OBJECT);
		object.emit_signal("my_custom_signal", "emit_arg");
		CHECK_EQ(target.received_args, Vector<Variant>{ "emit_arg", &object });
		object.disconnect("my_custom_signal", callable_mp(&target, &SignalReceiver::callback2));
	}
}

class NotificationObjectSuperclass : public Object {
	GDCLASS(NotificationObjectSuperclass, Object);

protected:
	void _notification(int p_what) {
		order_superclass = ++order_global;
	}

public:
	static inline int order_global = 0;
	int order_superclass = -1;
};

class NotificationObjectSubclass : public NotificationObjectSuperclass {
	GDCLASS(NotificationObjectSubclass, NotificationObjectSuperclass);

protected:
	void _notification(int p_what) {
		order_subclass = ++order_global;
	}

public:
	int order_subclass = -1;
};

class NotificationScriptInstance : public _MockScriptInstance {
	void notification(int p_notification, bool p_reversed) override {
		order_script = ++NotificationObjectSuperclass::order_global;
	}

public:
	int order_script = -1;
};

TEST_CASE("[Object] Notification order") { // GH-52325
	NotificationObjectSubclass *object = memnew(NotificationObjectSubclass);

	NotificationScriptInstance *script = memnew(NotificationScriptInstance);
	object->set_script_instance(script);

	SUBCASE("regular order") {
		NotificationObjectSubclass::order_global = 0;
		object->order_superclass = -1;
		object->order_subclass = -1;
		script->order_script = -1;
		object->notification(12345, false);

		CHECK_EQ(object->order_superclass, 1);
		CHECK_EQ(object->order_subclass, 2);
		// TODO If an extension is attached, it should come here.
		CHECK_EQ(script->order_script, 3);
		CHECK_EQ(NotificationObjectSubclass::order_global, 3);
	}

	SUBCASE("reverse order") {
		NotificationObjectSubclass::order_global = 0;
		object->order_superclass = -1;
		object->order_subclass = -1;
		script->order_script = -1;
		object->notification(12345, true);

		CHECK_EQ(script->order_script, 1);
		// TODO If an extension is attached, it should come here.
		CHECK_EQ(object->order_subclass, 2);
		CHECK_EQ(object->order_superclass, 3);
		CHECK_EQ(NotificationObjectSubclass::order_global, 3);
	}

	memdelete(object);
}

TEST_CASE("[Object] Destruction at the end of the call chain is safe") {
	Object *object = memnew(Object);
	ObjectID obj_id = object->get_instance_id();

	class _SelfDestroyingScriptInstance : public _MockScriptInstance {
		Object *self = nullptr;

		// This has to be static because ~Object() also destroys the script instance.
		static void free_self(Object *p_self) {
#if defined(ASAN_OR_TSAN_ENABLED)
			// Regular deletion is enough becausa asan/tsan will catch a potential heap-after-use.
			memdelete(p_self);
#else
			// Without asan/tsan, try at least to force a crash by replacing the otherwise seemingly good data with garbage.
			// Operations such as dereferencing pointers or decreasing a refcount would fail.
			// Unfortunately, we may not poison the memory after the deletion, because the memory would no longer belong to us
			// and on doing so we may cause a more generalized crash on some platforms (allocator implementations).
			p_self->~Object();
			memset((void *)p_self, 0, sizeof(Object));
			Memory::free_static(p_self, false);
#endif
		}

	public:
		Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override {
			free_self(self);
			return Variant();
		}
		Variant call_const(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override {
			free_self(self);
			return Variant();
		}
		bool has_method(const StringName &p_method) const override {
			return p_method == "some_method";
		}

	public:
		_SelfDestroyingScriptInstance(Object *p_self) :
				self(p_self) {}
	};

	_SelfDestroyingScriptInstance *script_instance = memnew(_SelfDestroyingScriptInstance(object));
	object->set_script_instance(script_instance);

	SUBCASE("Within callp()") {
		SUBCASE("Through call()") {
			object->call("some_method");
		}
		SUBCASE("Through callv()") {
			object->callv("some_method", Array());
		}
	}
	SUBCASE("Within call_const()") {
		Callable::CallError call_error;
		object->call_const("some_method", nullptr, 0, call_error);
	}
	SUBCASE("Within signal handling (from emit_signalp(), through emit_signal())") {
		Object emitter;
		emitter.add_user_signal(MethodInfo("some_signal"));
		emitter.connect("some_signal", Callable(object, "some_method"));
		emitter.emit_signal("some_signal");
	}

	CHECK_MESSAGE(
			ObjectDB::get_instance(obj_id) == nullptr,
			"Object was tail-deleted without crashes.");
}

int required_param_compare(const Ref<RefCounted> &p_ref, const RequiredParam<RefCounted> &rp_required) {
	EXTRACT_PARAM_OR_FAIL_V(p_required, rp_required, false);
	ERR_FAIL_COND_V(p_ref->get_reference_count() != p_required->get_reference_count(), -1);
	return p_ref->get_reference_count();
}

TEST_CASE("[Object] RequiredParam Ref<T>") {
	Ref<RefCounted> ref;
	ref.instantiate();
	const Ref<RefCounted> &ref_ref = ref;

	RequiredParam<RefCounted> required = ref;
	EXTRACT_PARAM_OR_FAIL(extract, required);

	static_assert(std::is_same_v<decltype(ref_ref), decltype(extract)>);

	CHECK_EQ(ref->get_reference_count(), extract->get_reference_count());

	const int count = required_param_compare(ref, ref);
	CHECK_NE(count, -1);
	CHECK_EQ(count, ref->get_reference_count());

	CHECK_EQ(ref->get_reference_count(), extract->get_reference_count());
}

TEST_CASE("[Object] RequiredResult") {
	Ref<RefCounted> ref;
	ref.instantiate();

	RequiredResult<RefCounted> required = ref;

	Ref<RefCounted> unpacked = required;
	Variant var = Ref<RefCounted>(required);

	CHECK_EQ(ref, unpacked);
	CHECK_EQ(ref, var);
}

} // namespace TestObject