Port ClassDB tests to use doctest

Extracted the most minimal core initialization functionality from
`setup()` and `setup2()` so that `ClassDB` could be tested properly
(input, audio, rendering, physics etc, are excluded).

Display and rendering servers/singletons are not initialized at all.

Due to the fact that most subsystems are disabled, fixed various crashes in the
process (in order):
- `AcceptDialog` OK/cancel swap behavior (used `DisplayServer` while
  `register_scene_types()`);
- `make_default_theme` which depends on `RenderingServer`;
- `XRServer` singleton access while calling `register_modules_types()`;
- hidden bug in a way joypads are cleaned up (MacOS and Linux only).

Removed manual `ClassDB` init/cleanup calls from `test_validate_testing.h`.

ClassDB tests:

Co-authored-by: Ignacio Etcheverry <[email protected]>

main/main.cpp

@@ -369,16 +369,94 @@ void Main::print_help(const char *p_binary) {
 #endif
 }
 
+#ifdef TESTS_ENABLED
+// The order is the same as in `Main::setup()`, only core and some editor types
+// are initialized here. This also combines `Main::setup2()` initialization.
+Error Main::test_setup() {
+	OS::get_singleton()->initialize();
+
+	engine = memnew(Engine);
+
+	ClassDB::init();
+
+	register_core_types();
+	register_core_driver_types();
+
+	globals = memnew(ProjectSettings);
+
+	GLOBAL_DEF("debug/settings/crash_handler/message",
+			String("Please include this when reporting the bug on https://github.com/godotengine/godot/issues"));
+
+	// From `Main::setup2()`.
+	preregister_module_types();
+	preregister_server_types();
+
+	register_core_singletons();
+
+	register_server_types();
+	register_scene_types();
+
+#ifdef TOOLS_ENABLED
+	ClassDB::set_current_api(ClassDB::API_EDITOR);
+	EditorNode::register_editor_types();
+
+	ClassDB::set_current_api(ClassDB::API_CORE);
+#endif
+	register_platform_apis();
+
+	register_module_types();
+	register_driver_types();
+
+	ClassDB::set_current_api(ClassDB::API_NONE);
+
+	_start_success = true;
+
+	return OK;
+}
+// The order is the same as in `Main::cleanup()`.
+void Main::test_cleanup() {
+	ERR_FAIL_COND(!_start_success);
+
+	EngineDebugger::deinitialize();
+
+	ResourceLoader::remove_custom_loaders();
+	ResourceSaver::remove_custom_savers();
+
+#ifdef TOOLS_ENABLED
+	EditorNode::unregister_editor_types();
+#endif
+	unregister_driver_types();
+	unregister_module_types();
+	unregister_platform_apis();
+	unregister_scene_types();
+	unregister_server_types();
+
+	OS::get_singleton()->finalize();
+
+	if (globals) {
+		memdelete(globals);
+	}
+	if (engine) {
+		memdelete(engine);
+	}
+
+	unregister_core_driver_types();
+	unregister_core_types();
+
+	OS::get_singleton()->finalize_core();
+}
+#endif
+
 int Main::test_entrypoint(int argc, char *argv[], bool &tests_need_run) {
 #ifdef TESTS_ENABLED
 	for (int x = 0; x < argc; x++) {
 		if ((strncmp(argv[x], "--test", 6) == 0) && (strlen(argv[x]) == 6)) {
 			tests_need_run = true;
-			OS::get_singleton()->initialize();
-			StringName::setup();
+			// TODO: need to come up with different test contexts.
+			// Not every test requires high-level functionality like `ClassDB`.
+			test_setup();
 			int status = test_main(argc, argv);
-			StringName::cleanup();
-			// TODO: fix OS::singleton cleanup
+			test_cleanup();
 			return status;
 		}
 	}

main/main.h

@@ -48,6 +48,10 @@ public:
 	static int test_entrypoint(int argc, char *argv[], bool &tests_need_run);
 	static Error setup(const char *execpath, int argc, char *argv[], bool p_second_phase = true);
 	static Error setup2(Thread::ID p_main_tid_override = 0);
+#ifdef TESTS_ENABLED
+	static Error test_setup();
+	static void test_cleanup();
+#endif
 	static bool start();
 
 	static bool iteration();
@@ -58,7 +62,7 @@ public:
 	static void cleanup();
 };
 
-// Test main override is for the testing behaviour
+// Test main override is for the testing behaviour.
 #define TEST_MAIN_OVERRIDE                                         \
 	bool run_test = false;                                         \
 	int return_code = Main::test_entrypoint(argc, argv, run_test); \

modules/mobile_vr/register_types.cpp

@@ -35,9 +35,11 @@
 void register_mobile_vr_types() {
 	ClassDB::register_class<MobileVRInterface>();
 
-	Ref<MobileVRInterface> mobile_vr;
-	mobile_vr.instance();
-	XRServer::get_singleton()->add_interface(mobile_vr);
+	if (XRServer::get_singleton()) {
+		Ref<MobileVRInterface> mobile_vr;
+		mobile_vr.instance();
+		XRServer::get_singleton()->add_interface(mobile_vr);
+	}
 }
 
 void unregister_mobile_vr_types() {

platform/linuxbsd/os_linuxbsd.cpp

@@ -88,7 +88,9 @@ void OS_LinuxBSD::finalize() {
 #endif
 
 #ifdef JOYDEV_ENABLED
-	memdelete(joypad);
+	if (joypad) {
+		memdelete(joypad);
+	}
 #endif
 }
 

platform/linuxbsd/os_linuxbsd.h

@@ -48,7 +48,7 @@ class OS_LinuxBSD : public OS_Unix {
 	bool force_quit;
 
 #ifdef JOYDEV_ENABLED
-	JoypadLinux *joypad;
+	JoypadLinux *joypad = nullptr;
 #endif
 
 #ifdef ALSA_ENABLED

platform/osx/os_osx.h

@@ -44,7 +44,7 @@ class OS_OSX : public OS_Unix {
 
 	bool force_quit;
 
-	JoypadOSX *joypad_osx;
+	JoypadOSX *joypad_osx = nullptr;
 
 #ifdef COREAUDIO_ENABLED
 	AudioDriverCoreAudio audio_driver;

platform/osx/os_osx.mm

@@ -145,7 +145,9 @@ void OS_OSX::finalize() {
 
 	delete_main_loop();
 
-	memdelete(joypad_osx);
+	if (joypad_osx) {
+		memdelete(joypad_osx);
+	}
 }
 
 void OS_OSX::set_main_loop(MainLoop *p_main_loop) {

scene/register_scene_types.cpp

@@ -372,7 +372,11 @@ void register_scene_types() {
 
 	OS::get_singleton()->yield(); //may take time to init
 
-	AcceptDialog::set_swap_cancel_ok(GLOBAL_DEF_NOVAL("gui/common/swap_cancel_ok", bool(DisplayServer::get_singleton()->get_swap_cancel_ok())));
+	bool swap_cancel_ok = false;
+	if (DisplayServer::get_singleton()) {
+		swap_cancel_ok = GLOBAL_DEF_NOVAL("gui/common/swap_cancel_ok", bool(DisplayServer::get_singleton()->get_swap_cancel_ok()));
+	}
+	AcceptDialog::set_swap_cancel_ok(swap_cancel_ok);
 #endif
 
 	/* REGISTER 3D */
@@ -912,8 +916,10 @@ void register_scene_types() {
 		}
 	}
 
-	// Always make the default theme to avoid invalid default font/icon/style in the given theme
-	make_default_theme(default_theme_hidpi, font);
+	// Always make the default theme to avoid invalid default font/icon/style in the given theme.
+	if (RenderingServer::get_singleton()) {
+		make_default_theme(default_theme_hidpi, font);
+	}
 
 	if (theme_path != String()) {
 		Ref<Theme> theme = ResourceLoader::load(theme_path);

tests/test_class_db.cpp

@@ -1,882 +0,0 @@
-/*************************************************************************/
-/*  test_class_db.cpp                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* 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 "test_class_db.h"
-
-#include "core/global_constants.h"
-#include "core/ordered_hash_map.h"
-#include "core/os/os.h"
-#include "core/string_name.h"
-#include "core/ustring.h"
-#include "core/variant.h"
-
-namespace TestClassDB {
-
-enum class [[nodiscard]] TestResult{
-	FAILED,
-	PASS
-};
-
-#define TEST_FAIL_COND(m_cond, m_msg) \
-	if (unlikely(m_cond)) {           \
-		ERR_PRINT(m_msg);             \
-		return TestResult::FAILED;    \
-	} else                            \
-		((void)0)
-
-#define TEST_COND(m_cond, m_msg)              \
-	if (unlikely(m_cond)) {                   \
-		ERR_PRINT(m_msg);                     \
-		__test_result__ = TestResult::FAILED; \
-	} else                                    \
-		((void)0)
-
-#define TEST_FAIL_CHECK(m_test_expr)                     \
-	if (unlikely((m_test_expr) == TestResult::FAILED)) { \
-		return TestResult::FAILED;                       \
-	} else                                               \
-		((void)0)
-
-#define TEST_CHECK(m_test_expr)                          \
-	if (unlikely((m_test_expr) == TestResult::FAILED)) { \
-		__test_result__ = TestResult::FAILED;            \
-	} else                                               \
-		((void)0)
-
-#define TEST_START()                               \
-	TestResult __test_result__ = TestResult::PASS; \
-	((void)0)
-
-#define TEST_END() return __test_result__;
-
-struct TypeReference {
-	StringName name;
-	bool is_enum = false;
-};
-
-struct ConstantData {
-	String name;
-	int value = 0;
-};
-
-struct EnumData {
-	StringName name;
-	List<ConstantData> constants;
-
-	_FORCE_INLINE_ bool operator==(const EnumData &p_enum) const {
-		return p_enum.name == name;
-	}
-};
-
-struct PropertyData {
-	StringName name;
-	int index = 0;
-
-	StringName getter;
-	StringName setter;
-};
-
-struct ArgumentData {
-	TypeReference type;
-	String name;
-	bool has_defval = false;
-	Variant defval;
-};
-
-struct MethodData {
-	StringName name;
-	TypeReference return_type;
-	List<ArgumentData> arguments;
-	bool is_virtual = false;
-	bool is_vararg = false;
-};
-
-struct SignalData {
-	StringName name;
-	List<ArgumentData> arguments;
-};
-
-struct ExposedClass {
-	StringName name;
-	StringName base;
-
-	bool is_singleton = false;
-	bool is_instantiable = false;
-	bool is_reference = false;
-
-	ClassDB::APIType api_type;
-
-	List<ConstantData> constants;
-	List<EnumData> enums;
-	List<PropertyData> properties;
-	List<MethodData> methods;
-	List<SignalData> signals_;
-
-	const PropertyData *find_property_by_name(const StringName &p_name) const {
-		for (const List<PropertyData>::Element *E = properties.front(); E; E = E->next()) {
-			if (E->get().name == p_name) {
-				return &E->get();
-			}
-		}
-
-		return nullptr;
-	}
-
-	const MethodData *find_method_by_name(const StringName &p_name) const {
-		for (const List<MethodData>::Element *E = methods.front(); E; E = E->next()) {
-			if (E->get().name == p_name) {
-				return &E->get();
-			}
-		}
-
-		return nullptr;
-	}
-};
-
-struct NamesCache {
-	StringName variant_type = StaticCString::create("Variant");
-	StringName object_class = StaticCString::create("Object");
-	StringName reference_class = StaticCString::create("Reference");
-	StringName string_type = StaticCString::create("String");
-	StringName string_name_type = StaticCString::create("StringName");
-	StringName node_path_type = StaticCString::create("NodePath");
-	StringName bool_type = StaticCString::create("bool");
-	StringName int_type = StaticCString::create("int");
-	StringName float_type = StaticCString::create("float");
-	StringName void_type = StaticCString::create("void");
-	StringName vararg_stub_type = StaticCString::create("@VarArg@");
-	StringName vector2_type = StaticCString::create("Vector2");
-	StringName rect2_type = StaticCString::create("Rect2");
-	StringName vector3_type = StaticCString::create("Vector3");
-
-	// Object not included as it must be checked for all derived classes
-	static constexpr int nullable_types_count = 17;
-	StringName nullable_types[nullable_types_count] = {
-		string_type,
-		string_name_type,
-		node_path_type,
-
-		StaticCString::create(_STR(Array)),
-		StaticCString::create(_STR(Dictionary)),
-		StaticCString::create(_STR(Callable)),
-		StaticCString::create(_STR(Signal)),
-
-		StaticCString::create(_STR(PackedByteArray)),
-		StaticCString::create(_STR(PackedInt32Array)),
-		StaticCString::create(_STR(PackedInt64rray)),
-		StaticCString::create(_STR(PackedFloat32Array)),
-		StaticCString::create(_STR(PackedFloat64Array)),
-		StaticCString::create(_STR(PackedStringArray)),
-		StaticCString::create(_STR(PackedVector2Array)),
-		StaticCString::create(_STR(PackedVector3Array)),
-		StaticCString::create(_STR(PackedColorArray)),
-	};
-
-	bool is_nullable_type(const StringName &p_type) const {
-		for (int i = 0; i < nullable_types_count; i++) {
-			if (p_type == nullable_types[i]) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-};
-
-typedef OrderedHashMap<StringName, ExposedClass> ExposedClasses;
-
-struct Context {
-	Vector<StringName> enum_types;
-	Vector<StringName> builtin_types;
-	ExposedClasses exposed_classes;
-	List<EnumData> global_enums;
-	NamesCache names_cache;
-
-	const ExposedClass *find_exposed_class(const StringName &p_name) const {
-		ExposedClasses::ConstElement elem = exposed_classes.find(p_name);
-		return elem ? &elem.value() : nullptr;
-	}
-
-	const ExposedClass *find_exposed_class(const TypeReference &p_type_ref) const {
-		ExposedClasses::ConstElement elem = exposed_classes.find(p_type_ref.name);
-		return elem ? &elem.value() : nullptr;
-	}
-
-	bool has_type(const TypeReference &p_type_ref) const {
-		if (builtin_types.find(p_type_ref.name) >= 0) {
-			return true;
-		}
-
-		if (p_type_ref.is_enum) {
-			if (enum_types.find(p_type_ref.name) >= 0) {
-				return true;
-			}
-
-			// Enum not found. Most likely because none of its constants were bound, so it's empty. That's fine. Use int instead.
-			return builtin_types.find(names_cache.int_type);
-		}
-
-		return false;
-	}
-};
-
-bool arg_default_value_is_assignable_to_type(const Context &p_context, const Variant &p_val, const TypeReference &p_arg_type) {
-	if (p_arg_type.name == p_context.names_cache.variant_type) {
-		// Variant can take anything
-		return true;
-	}
-
-	switch (p_val.get_type()) {
-		case Variant::NIL:
-			return p_context.find_exposed_class(p_arg_type) ||
-				   p_context.names_cache.is_nullable_type(p_arg_type.name);
-		case Variant::BOOL:
-			return p_arg_type.name == p_context.names_cache.bool_type;
-		case Variant::INT:
-			return p_arg_type.name == p_context.names_cache.int_type ||
-				   p_arg_type.name == p_context.names_cache.float_type ||
-				   p_arg_type.is_enum;
-		case Variant::FLOAT:
-			return p_arg_type.name == p_context.names_cache.float_type;
-		case Variant::STRING:
-		case Variant::STRING_NAME:
-			return p_arg_type.name == p_context.names_cache.string_type ||
-				   p_arg_type.name == p_context.names_cache.string_name_type ||
-				   p_arg_type.name == p_context.names_cache.node_path_type;
-		case Variant::NODE_PATH:
-			return p_arg_type.name == p_context.names_cache.node_path_type;
-		case Variant::TRANSFORM:
-		case Variant::TRANSFORM2D:
-		case Variant::BASIS:
-		case Variant::QUAT:
-		case Variant::PLANE:
-		case Variant::AABB:
-		case Variant::COLOR:
-		case Variant::VECTOR2:
-		case Variant::RECT2:
-		case Variant::VECTOR3:
-		case Variant::_RID:
-		case Variant::ARRAY:
-		case Variant::DICTIONARY:
-		case Variant::PACKED_BYTE_ARRAY:
-		case Variant::PACKED_INT32_ARRAY:
-		case Variant::PACKED_INT64_ARRAY:
-		case Variant::PACKED_FLOAT32_ARRAY:
-		case Variant::PACKED_FLOAT64_ARRAY:
-		case Variant::PACKED_STRING_ARRAY:
-		case Variant::PACKED_VECTOR2_ARRAY:
-		case Variant::PACKED_VECTOR3_ARRAY:
-		case Variant::PACKED_COLOR_ARRAY:
-		case Variant::CALLABLE:
-		case Variant::SIGNAL:
-			return p_arg_type.name == Variant::get_type_name(p_val.get_type());
-		case Variant::OBJECT:
-			return p_context.find_exposed_class(p_arg_type);
-		case Variant::VECTOR2I:
-			return p_arg_type.name == p_context.names_cache.vector2_type ||
-				   p_arg_type.name == Variant::get_type_name(p_val.get_type());
-		case Variant::RECT2I:
-			return p_arg_type.name == p_context.names_cache.rect2_type ||
-				   p_arg_type.name == Variant::get_type_name(p_val.get_type());
-		case Variant::VECTOR3I:
-			return p_arg_type.name == p_context.names_cache.vector3_type ||
-				   p_arg_type.name == Variant::get_type_name(p_val.get_type());
-		default:
-			ERR_PRINT("Unexpected Variant type: " + itos(p_val.get_type()));
-			break;
-	}
-
-	return false;
-}
-
-TestResult validate_property(const Context &p_context, const ExposedClass &p_class, const PropertyData &p_prop) {
-	TEST_START();
-
-	const MethodData *setter = p_class.find_method_by_name(p_prop.setter);
-
-	// Search it in base classes too
-	const ExposedClass *top = &p_class;
-	while (!setter && top->base != StringName()) {
-		top = p_context.find_exposed_class(top->base);
-		TEST_FAIL_COND(!top, "Class not found '" + top->base + "'. Inherited by '" + top->name + "'.");
-		setter = top->find_method_by_name(p_prop.setter);
-	}
-
-	const MethodData *getter = p_class.find_method_by_name(p_prop.getter);
-
-	// Search it in base classes too
-	top = &p_class;
-	while (!getter && top->base != StringName()) {
-		top = p_context.find_exposed_class(top->base);
-		TEST_FAIL_COND(!top, "Class not found '" + top->base + "'. Inherited by '" + top->name + "'.");
-		getter = top->find_method_by_name(p_prop.getter);
-	}
-
-	TEST_FAIL_COND(!setter && !getter,
-			"Couldn't find neither the setter nor the getter for property: '" + p_class.name + "." + String(p_prop.name) + "'.");
-
-	if (setter) {
-		int setter_argc = p_prop.index != -1 ? 2 : 1;
-		TEST_FAIL_COND(setter->arguments.size() != setter_argc,
-				"Invalid property setter argument count: '" + p_class.name + "." + String(p_prop.name) + "'.");
-	}
-
-	if (getter) {
-		int getter_argc = p_prop.index != -1 ? 1 : 0;
-		TEST_FAIL_COND(getter->arguments.size() != getter_argc,
-				"Invalid property setter argument count: '" + p_class.name + "." + String(p_prop.name) + "'.");
-	}
-
-	if (getter && setter) {
-		const ArgumentData &setter_first_arg = setter->arguments.back()->get();
-		if (getter->return_type.name != setter_first_arg.type.name) {
-			// Special case for Node::set_name
-			bool whitelisted = getter->return_type.name == p_context.names_cache.string_name_type &&
-							   setter_first_arg.type.name == p_context.names_cache.string_type;
-
-			TEST_FAIL_COND(!whitelisted,
-					"Return type from getter doesn't match first argument of setter, for property: '" + p_class.name + "." + String(p_prop.name) + "'.");
-		}
-	}
-
-	const TypeReference &prop_type_ref = getter ? getter->return_type : setter->arguments.back()->get().type;
-
-	const ExposedClass *prop_class = p_context.find_exposed_class(prop_type_ref);
-	if (prop_class) {
-		TEST_COND(prop_class->is_singleton,
-				"Property type is a singleton: '" + p_class.name + "." + String(p_prop.name) + "'.");
-	} else {
-		TEST_FAIL_COND(!p_context.has_type(prop_type_ref),
-				"Property type '" + prop_type_ref.name + "' not found: '" + p_class.name + "." + String(p_prop.name) + "'.");
-	}
-
-	if (getter) {
-		if (p_prop.index != -1) {
-			const ArgumentData &idx_arg = getter->arguments.front()->get();
-			if (idx_arg.type.name != p_context.names_cache.int_type) {
-				// If not an int, it can be an enum
-				TEST_COND(p_context.enum_types.find(idx_arg.type.name) < 0,
-						"Invalid type '" + idx_arg.type.name + "' for index argument of property getter: '" + p_class.name + "." + String(p_prop.name) + "'.");
-			}
-		}
-	}
-
-	if (setter) {
-		if (p_prop.index != -1) {
-			const ArgumentData &idx_arg = setter->arguments.front()->get();
-			if (idx_arg.type.name != p_context.names_cache.int_type) {
-				// Assume the index parameter is an enum
-				// If not an int, it can be an enum
-				TEST_COND(p_context.enum_types.find(idx_arg.type.name) < 0,
-						"Invalid type '" + idx_arg.type.name + "' for index argument of property setter: '" + p_class.name + "." + String(p_prop.name) + "'.");
-			}
-		}
-	}
-
-	TEST_END();
-}
-
-TestResult validate_method(const Context &p_context, const ExposedClass &p_class, const MethodData &p_method) {
-	TEST_START();
-
-	const ExposedClass *return_class = p_context.find_exposed_class(p_method.return_type);
-	if (return_class) {
-		TEST_COND(return_class->is_singleton,
-				"Method return type is a singleton: '" + p_class.name + "." + p_method.name + "'.");
-	}
-
-	for (const List<ArgumentData>::Element *F = p_method.arguments.front(); F; F = F->next()) {
-		const ArgumentData &arg = F->get();
-
-		const ExposedClass *arg_class = p_context.find_exposed_class(arg.type);
-		if (arg_class) {
-			TEST_COND(arg_class->is_singleton,
-					"Argument type is a singleton: '" + arg.name + "' of method '" + p_class.name + "." + p_method.name + "'.");
-		} else {
-			TEST_FAIL_COND(!p_context.has_type(arg.type),
-					"Argument type '" + arg.type.name + "' not found: '" + arg.name + "' of method" + p_class.name + "." + p_method.name + "'.");
-		}
-
-		if (arg.has_defval) {
-			TEST_COND(!arg_default_value_is_assignable_to_type(p_context, arg.defval, arg.type),
-					"Invalid default value for parameter '" + arg.name + "' of method '" + p_class.name + "." + p_method.name + "'.");
-		}
-	}
-
-	TEST_END();
-}
-
-TestResult validate_signal(const Context &p_context, const ExposedClass &p_class, const SignalData &p_signal) {
-	TEST_START();
-
-	for (const List<ArgumentData>::Element *F = p_signal.arguments.front(); F; F = F->next()) {
-		const ArgumentData &arg = F->get();
-
-		const ExposedClass *arg_class = p_context.find_exposed_class(arg.type);
-		if (arg_class) {
-			TEST_COND(arg_class->is_singleton,
-					"Argument class is a singleton: '" + arg.name + "' of signal" + p_class.name + "." + p_signal.name + "'.");
-		} else {
-			TEST_FAIL_COND(!p_context.has_type(arg.type),
-					"Argument type '" + arg.type.name + "' not found: '" + arg.name + "' of signal" + p_class.name + "." + p_signal.name + "'.");
-		}
-	}
-
-	TEST_END();
-}
-
-TestResult validate_class(const Context &p_context, const ExposedClass &p_exposed_class) {
-	TEST_START();
-
-	bool is_derived_type = p_exposed_class.base != StringName();
-
-	if (!is_derived_type) {
-		// Asserts about the base Object class
-		TEST_FAIL_COND(p_exposed_class.name != p_context.names_cache.object_class,
-				"Class '" + p_exposed_class.name + "' has no base class.");
-		TEST_FAIL_COND(!p_exposed_class.is_instantiable,
-				"Object class is not instantiable.");
-		TEST_FAIL_COND(p_exposed_class.api_type != ClassDB::API_CORE,
-				"Object class is API is not API_CORE.");
-		TEST_FAIL_COND(p_exposed_class.is_singleton,
-				"Object class is registered as a singleton.");
-	}
-
-	TEST_FAIL_COND(p_exposed_class.is_singleton && p_exposed_class.base != p_context.names_cache.object_class,
-			"Singleton base class '" + String(p_exposed_class.base) + "' is not Object, for class '" + p_exposed_class.name + "'.");
-
-	TEST_FAIL_COND(is_derived_type && !p_context.exposed_classes.has(p_exposed_class.base),
-			"Base type '" + p_exposed_class.base.operator String() + "' does not exist, for class '" + p_exposed_class.name + "'.");
-
-	for (const List<PropertyData>::Element *F = p_exposed_class.properties.front(); F; F = F->next()) {
-		TEST_CHECK(validate_property(p_context, p_exposed_class, F->get()));
-	}
-
-	for (const List<MethodData>::Element *F = p_exposed_class.methods.front(); F; F = F->next()) {
-		TEST_CHECK(validate_method(p_context, p_exposed_class, F->get()));
-	}
-
-	for (const List<SignalData>::Element *F = p_exposed_class.signals_.front(); F; F = F->next()) {
-		TEST_CHECK(validate_signal(p_context, p_exposed_class, F->get()));
-	}
-
-	TEST_END();
-}
-
-TestResult add_exposed_classes(Context &r_context) {
-	TEST_START();
-
-	List<StringName> class_list;
-	ClassDB::get_class_list(&class_list);
-	class_list.sort_custom<StringName::AlphCompare>();
-
-	while (class_list.size()) {
-		StringName class_name = class_list.front()->get();
-
-		ClassDB::APIType api_type = ClassDB::get_api_type(class_name);
-
-		if (api_type == ClassDB::API_NONE) {
-			class_list.pop_front();
-			continue;
-		}
-
-		if (!ClassDB::is_class_exposed(class_name)) {
-			OS::get_singleton()->print("Ignoring class '%s' because it's not exposed\n", String(class_name).utf8().get_data());
-			class_list.pop_front();
-			continue;
-		}
-
-		if (!ClassDB::is_class_enabled(class_name)) {
-			OS::get_singleton()->print("Ignoring class '%s' because it's not enabled\n", String(class_name).utf8().get_data());
-			class_list.pop_front();
-			continue;
-		}
-
-		ClassDB::ClassInfo *class_info = ClassDB::classes.getptr(class_name);
-
-		ExposedClass exposed_class;
-		exposed_class.name = class_name;
-		exposed_class.api_type = api_type;
-		exposed_class.is_singleton = Engine::get_singleton()->has_singleton(class_name);
-		exposed_class.is_instantiable = class_info->creation_func && !exposed_class.is_singleton;
-		exposed_class.is_reference = ClassDB::is_parent_class(class_name, "Reference");
-		exposed_class.base = ClassDB::get_parent_class(class_name);
-
-		// Add properties
-
-		List<PropertyInfo> property_list;
-		ClassDB::get_property_list(class_name, &property_list, true);
-
-		Map<StringName, StringName> accessor_methods;
-
-		for (const List<PropertyInfo>::Element *E = property_list.front(); E; E = E->next()) {
-			const PropertyInfo &property = E->get();
-
-			if (property.usage & PROPERTY_USAGE_GROUP || property.usage & PROPERTY_USAGE_SUBGROUP || property.usage & PROPERTY_USAGE_CATEGORY) {
-				continue;
-			}
-
-			PropertyData prop;
-			prop.name = property.name;
-			prop.setter = ClassDB::get_property_setter(class_name, prop.name);
-			prop.getter = ClassDB::get_property_getter(class_name, prop.name);
-
-			if (prop.setter != StringName()) {
-				accessor_methods[prop.setter] = prop.name;
-			}
-			if (prop.getter != StringName()) {
-				accessor_methods[prop.getter] = prop.name;
-			}
-
-			bool valid = false;
-			prop.index = ClassDB::get_property_index(class_name, prop.name, &valid);
-			TEST_FAIL_COND(!valid, "Invalid property: '" + exposed_class.name + "." + String(prop.name) + "'.");
-
-			exposed_class.properties.push_back(prop);
-		}
-
-		// Add methods
-
-		List<MethodInfo> virtual_method_list;
-		ClassDB::get_virtual_methods(class_name, &virtual_method_list, true);
-
-		List<MethodInfo> method_list;
-		ClassDB::get_method_list(class_name, &method_list, true);
-		method_list.sort();
-
-		for (List<MethodInfo>::Element *E = method_list.front(); E; E = E->next()) {
-			const MethodInfo &method_info = E->get();
-
-			int argc = method_info.arguments.size();
-
-			if (method_info.name.empty()) {
-				continue;
-			}
-
-			MethodData method;
-			method.name = method_info.name;
-
-			if (method_info.flags & METHOD_FLAG_VIRTUAL) {
-				method.is_virtual = true;
-			}
-
-			PropertyInfo return_info = method_info.return_val;
-
-			MethodBind *m = method.is_virtual ? nullptr : ClassDB::get_method(class_name, method_info.name);
-
-			method.is_vararg = m && m->is_vararg();
-
-			if (!m && !method.is_virtual) {
-				TEST_FAIL_COND(!virtual_method_list.find(method_info),
-						"Missing MethodBind for non-virtual method: '" + exposed_class.name + "." + method.name + "'.");
-
-				// A virtual method without the virtual flag. This is a special case.
-
-				// The method Object.free is registered as a virtual method, but without the virtual flag.
-				// This is because this method is not supposed to be overridden, but called.
-				// We assume the return type is void.
-				method.return_type.name = r_context.names_cache.void_type;
-
-				// Actually, more methods like this may be added in the future, which could return
-				// something different. Let's put this check to notify us if that ever happens.
-				if (exposed_class.name != r_context.names_cache.object_class || String(method.name) != "free") {
-					WARN_PRINT("Notification: New unexpected virtual non-overridable method found."
-							   " We only expected Object.free, but found '" +
-							   exposed_class.name + "." + method.name + "'.");
-				}
-			} else if (return_info.type == Variant::INT && return_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
-				method.return_type.name = return_info.class_name;
-				method.return_type.is_enum = true;
-			} else if (return_info.class_name != StringName()) {
-				method.return_type.name = return_info.class_name;
-
-				bool bad_reference_hint = !method.is_virtual && return_info.hint != PROPERTY_HINT_RESOURCE_TYPE &&
-										  ClassDB::is_parent_class(return_info.class_name, r_context.names_cache.reference_class);
-				TEST_COND(bad_reference_hint, String() + "Return type is reference but hint is not '" _STR(PROPERTY_HINT_RESOURCE_TYPE) "'." +
-													  " Are you returning a reference type by pointer? Method: '" +
-													  exposed_class.name + "." + method.name + "'.");
-			} else if (return_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
-				method.return_type.name = return_info.hint_string;
-			} else if (return_info.type == Variant::NIL && return_info.usage & PROPERTY_USAGE_NIL_IS_VARIANT) {
-				method.return_type.name = r_context.names_cache.variant_type;
-			} else if (return_info.type == Variant::NIL) {
-				method.return_type.name = r_context.names_cache.void_type;
-			} else {
-				// NOTE: We don't care about the size and sign of int and float in these tests
-				method.return_type.name = Variant::get_type_name(return_info.type);
-			}
-
-			for (int i = 0; i < argc; i++) {
-				PropertyInfo arg_info = method_info.arguments[i];
-
-				String orig_arg_name = arg_info.name;
-
-				ArgumentData arg;
-				arg.name = orig_arg_name;
-
-				if (arg_info.type == Variant::INT && arg_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
-					arg.type.name = arg_info.class_name;
-					arg.type.is_enum = true;
-				} else if (arg_info.class_name != StringName()) {
-					arg.type.name = arg_info.class_name;
-				} else if (arg_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
-					arg.type.name = arg_info.hint_string;
-				} else if (arg_info.type == Variant::NIL) {
-					arg.type.name = r_context.names_cache.variant_type;
-				} else {
-					// NOTE: We don't care about the size and sign of int and float in these tests
-					arg.type.name = Variant::get_type_name(arg_info.type);
-				}
-
-				if (m && m->has_default_argument(i)) {
-					arg.has_defval = true;
-					arg.defval = m->get_default_argument(i);
-				}
-
-				method.arguments.push_back(arg);
-			}
-
-			if (method.is_vararg) {
-				ArgumentData vararg;
-				vararg.type.name = r_context.names_cache.vararg_stub_type;
-				vararg.name = "@varargs@";
-				method.arguments.push_back(vararg);
-			}
-
-			TEST_COND(exposed_class.find_property_by_name(method.name),
-					"Method name conflicts with property: '" + String(class_name) + "." + String(method.name) + "'.");
-
-			// Classes starting with an underscore are ignored unless they're used as a property setter or getter
-			if (!method.is_virtual && String(method.name)[0] == '_') {
-				for (const List<PropertyData>::Element *F = exposed_class.properties.front(); F; F = F->next()) {
-					const PropertyData &prop = F->get();
-
-					if (prop.setter == method.name || prop.getter == method.name) {
-						exposed_class.methods.push_back(method);
-						break;
-					}
-				}
-			} else {
-				exposed_class.methods.push_back(method);
-			}
-		}
-
-		// Add signals
-
-		const HashMap<StringName, MethodInfo> &signal_map = class_info->signal_map;
-		const StringName *k = nullptr;
-
-		while ((k = signal_map.next(k))) {
-			SignalData signal;
-
-			const MethodInfo &method_info = signal_map.get(*k);
-
-			signal.name = method_info.name;
-
-			int argc = method_info.arguments.size();
-
-			for (int i = 0; i < argc; i++) {
-				PropertyInfo arg_info = method_info.arguments[i];
-
-				String orig_arg_name = arg_info.name;
-
-				ArgumentData arg;
-				arg.name = orig_arg_name;
-
-				if (arg_info.type == Variant::INT && arg_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
-					arg.type.name = arg_info.class_name;
-					arg.type.is_enum = true;
-				} else if (arg_info.class_name != StringName()) {
-					arg.type.name = arg_info.class_name;
-				} else if (arg_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
-					arg.type.name = arg_info.hint_string;
-				} else if (arg_info.type == Variant::NIL) {
-					arg.type.name = r_context.names_cache.variant_type;
-				} else {
-					// NOTE: We don't care about the size and sign of int and float in these tests
-					arg.type.name = Variant::get_type_name(arg_info.type);
-				}
-
-				signal.arguments.push_back(arg);
-			}
-
-			bool method_conflict = exposed_class.find_property_by_name(signal.name);
-
-			if (method_conflict || exposed_class.find_method_by_name(signal.name)) {
-				// TODO:
-				// ClassDB allows signal names that conflict with method or property names.
-				// However registering a signal with a conflicting name is still considered wrong.
-				// Unfortunately there are some existing cases that are yet to be fixed.
-				// Until those are fixed we will print a warning instead of failing the test.
-				WARN_PRINT("Signal name conflicts with " + String(method_conflict ? "method" : "property") +
-						   ": '" + String(class_name) + "." + String(signal.name) + "'.");
-			}
-
-			exposed_class.signals_.push_back(signal);
-		}
-
-		// Add enums and constants
-
-		List<String> constants;
-		ClassDB::get_integer_constant_list(class_name, &constants, true);
-
-		const HashMap<StringName, List<StringName>> &enum_map = class_info->enum_map;
-		k = nullptr;
-
-		while ((k = enum_map.next(k))) {
-			EnumData enum_;
-			enum_.name = *k;
-
-			const List<StringName> &enum_constants = enum_map.get(*k);
-			for (const List<StringName>::Element *E = enum_constants.front(); E; E = E->next()) {
-				const StringName &constant_name = E->get();
-				int *value = class_info->constant_map.getptr(constant_name);
-				TEST_FAIL_COND(!value, "Missing enum constant value: '" +
-											   String(class_name) + "." + String(enum_.name) + "." + String(constant_name) + "'.");
-				constants.erase(constant_name);
-
-				ConstantData constant;
-				constant.name = constant_name;
-				constant.value = *value;
-
-				enum_.constants.push_back(constant);
-			}
-
-			exposed_class.enums.push_back(enum_);
-
-			r_context.enum_types.push_back(String(class_name) + "." + String(*k));
-		}
-
-		for (const List<String>::Element *E = constants.front(); E; E = E->next()) {
-			const String &constant_name = E->get();
-			int *value = class_info->constant_map.getptr(StringName(E->get()));
-			TEST_FAIL_COND(!value, "Missing enum constant value: '" + String(class_name) + "." + String(constant_name) + "'.");
-
-			ConstantData constant;
-			constant.name = constant_name;
-			constant.value = *value;
-
-			exposed_class.constants.push_back(constant);
-		}
-
-		r_context.exposed_classes.insert(class_name, exposed_class);
-		class_list.pop_front();
-	}
-
-	TEST_END();
-}
-
-void add_builtin_types(Context &r_context) {
-	// NOTE: We don't care about the size and sign of int and float in these tests
-	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
-		r_context.builtin_types.push_back(Variant::get_type_name(Variant::Type(i)));
-	}
-
-	r_context.builtin_types.push_back(_STR(Variant));
-	r_context.builtin_types.push_back(r_context.names_cache.vararg_stub_type);
-	r_context.builtin_types.push_back("void");
-}
-
-void add_global_enums(Context &r_context) {
-	int global_constants_count = GlobalConstants::get_global_constant_count();
-
-	if (global_constants_count > 0) {
-		for (int i = 0; i < global_constants_count; i++) {
-			StringName enum_name = GlobalConstants::get_global_constant_enum(i);
-
-			if (enum_name != StringName()) {
-				ConstantData constant;
-				constant.name = GlobalConstants::get_global_constant_name(i);
-				constant.value = GlobalConstants::get_global_constant_value(i);
-
-				EnumData enum_;
-				enum_.name = enum_name;
-				List<EnumData>::Element *enum_match = r_context.global_enums.find(enum_);
-				if (enum_match) {
-					enum_match->get().constants.push_back(constant);
-				} else {
-					enum_.constants.push_back(constant);
-					r_context.global_enums.push_back(enum_);
-				}
-			}
-		}
-
-		for (List<EnumData>::Element *E = r_context.global_enums.front(); E; E = E->next()) {
-			r_context.enum_types.push_back(E->get().name);
-		}
-	}
-
-	// HARDCODED
-	List<StringName> hardcoded_enums;
-	hardcoded_enums.push_back("Vector2.Axis");
-	hardcoded_enums.push_back("Vector2i.Axis");
-	hardcoded_enums.push_back("Vector3.Axis");
-	hardcoded_enums.push_back("Vector3i.Axis");
-	for (List<StringName>::Element *E = hardcoded_enums.front(); E; E = E->next()) {
-		// These enums are not generated and must be written manually (e.g.: Vector3.Axis)
-		// Here, we assume core types do not begin with underscore
-		r_context.enum_types.push_back(E->get());
-	}
-}
-
-TestResult run_class_db_tests() {
-	TEST_START();
-
-	Context context;
-
-	TEST_FAIL_CHECK(add_exposed_classes(context));
-	add_builtin_types(context);
-	add_global_enums(context);
-
-	const ExposedClass *object_class = context.find_exposed_class(context.names_cache.object_class);
-	TEST_FAIL_COND(!object_class, "Object class not found.");
-	TEST_FAIL_COND(object_class->base != StringName(),
-			"Object class derives from another class: '" + object_class->base + "'.");
-
-	for (ExposedClasses::Element E = context.exposed_classes.front(); E; E = E.next()) {
-		TEST_CHECK(validate_class(context, E.value()));
-	}
-
-	TEST_END();
-}
-
-MainLoop *test() {
-	TestResult pass = run_class_db_tests();
-
-	OS::get_singleton()->print("ClassDB tests: %s\n", pass == TestResult::PASS ? "PASS" : "FAILED");
-
-	if (pass == TestResult::FAILED) {
-		OS::get_singleton()->set_exit_code(pass == TestResult::PASS ? 0 : 1);
-	}
-
-	return nullptr;
-}
-
-} // namespace TestClassDB

tests/test_class_db.h

@@ -31,12 +31,806 @@
 #ifndef GODOT_TEST_CLASS_DB_H
 #define GODOT_TEST_CLASS_DB_H
 
-#include "core/os/main_loop.h"
+#include "core/register_core_types.h"
+
+#include "core/global_constants.h"
+#include "core/ordered_hash_map.h"
+#include "core/os/os.h"
+#include "core/string_name.h"
+#include "core/ustring.h"
+#include "core/variant.h"
+
+#include "tests/test_macros.h"
+
+#define TEST_COND DOCTEST_CHECK_FALSE_MESSAGE
+#define TEST_FAIL DOCTEST_FAIL
+#define TEST_FAIL_COND DOCTEST_REQUIRE_FALSE_MESSAGE
+#define TEST_FAIL_COND_WARN DOCTEST_WARN_FALSE_MESSAGE
 
 namespace TestClassDB {
 
-MainLoop *test();
+struct TypeReference {
+	StringName name;
+	bool is_enum = false;
+};
+
+struct ConstantData {
+	String name;
+	int value = 0;
+};
+
+struct EnumData {
+	StringName name;
+	List<ConstantData> constants;
+
+	_FORCE_INLINE_ bool operator==(const EnumData &p_enum) const {
+		return p_enum.name == name;
+	}
+};
+
+struct PropertyData {
+	StringName name;
+	int index = 0;
+
+	StringName getter;
+	StringName setter;
+};
+
+struct ArgumentData {
+	TypeReference type;
+	String name;
+	bool has_defval = false;
+	Variant defval;
+};
+
+struct MethodData {
+	StringName name;
+	TypeReference return_type;
+	List<ArgumentData> arguments;
+	bool is_virtual = false;
+	bool is_vararg = false;
+};
+
+struct SignalData {
+	StringName name;
+	List<ArgumentData> arguments;
+};
+
+struct ExposedClass {
+	StringName name;
+	StringName base;
+
+	bool is_singleton = false;
+	bool is_instantiable = false;
+	bool is_reference = false;
+
+	ClassDB::APIType api_type;
+
+	List<ConstantData> constants;
+	List<EnumData> enums;
+	List<PropertyData> properties;
+	List<MethodData> methods;
+	List<SignalData> signals_;
+
+	const PropertyData *find_property_by_name(const StringName &p_name) const {
+		for (const List<PropertyData>::Element *E = properties.front(); E; E = E->next()) {
+			if (E->get().name == p_name) {
+				return &E->get();
+			}
+		}
+
+		return nullptr;
+	}
+
+	const MethodData *find_method_by_name(const StringName &p_name) const {
+		for (const List<MethodData>::Element *E = methods.front(); E; E = E->next()) {
+			if (E->get().name == p_name) {
+				return &E->get();
+			}
+		}
+
+		return nullptr;
+	}
+};
+
+struct NamesCache {
+	StringName variant_type = StaticCString::create("Variant");
+	StringName object_class = StaticCString::create("Object");
+	StringName reference_class = StaticCString::create("Reference");
+	StringName string_type = StaticCString::create("String");
+	StringName string_name_type = StaticCString::create("StringName");
+	StringName node_path_type = StaticCString::create("NodePath");
+	StringName bool_type = StaticCString::create("bool");
+	StringName int_type = StaticCString::create("int");
+	StringName float_type = StaticCString::create("float");
+	StringName void_type = StaticCString::create("void");
+	StringName vararg_stub_type = StaticCString::create("@VarArg@");
+	StringName vector2_type = StaticCString::create("Vector2");
+	StringName rect2_type = StaticCString::create("Rect2");
+	StringName vector3_type = StaticCString::create("Vector3");
 
+	// Object not included as it must be checked for all derived classes
+	static constexpr int nullable_types_count = 17;
+	StringName nullable_types[nullable_types_count] = {
+		string_type,
+		string_name_type,
+		node_path_type,
+
+		StaticCString::create(_STR(Array)),
+		StaticCString::create(_STR(Dictionary)),
+		StaticCString::create(_STR(Callable)),
+		StaticCString::create(_STR(Signal)),
+
+		StaticCString::create(_STR(PackedByteArray)),
+		StaticCString::create(_STR(PackedInt32Array)),
+		StaticCString::create(_STR(PackedInt64rray)),
+		StaticCString::create(_STR(PackedFloat32Array)),
+		StaticCString::create(_STR(PackedFloat64Array)),
+		StaticCString::create(_STR(PackedStringArray)),
+		StaticCString::create(_STR(PackedVector2Array)),
+		StaticCString::create(_STR(PackedVector3Array)),
+		StaticCString::create(_STR(PackedColorArray)),
+	};
+
+	bool is_nullable_type(const StringName &p_type) const {
+		for (int i = 0; i < nullable_types_count; i++) {
+			if (p_type == nullable_types[i]) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+};
+
+typedef OrderedHashMap<StringName, ExposedClass> ExposedClasses;
+
+struct Context {
+	Vector<StringName> enum_types;
+	Vector<StringName> builtin_types;
+	ExposedClasses exposed_classes;
+	List<EnumData> global_enums;
+	NamesCache names_cache;
+
+	const ExposedClass *find_exposed_class(const StringName &p_name) const {
+		ExposedClasses::ConstElement elem = exposed_classes.find(p_name);
+		return elem ? &elem.value() : nullptr;
+	}
+
+	const ExposedClass *find_exposed_class(const TypeReference &p_type_ref) const {
+		ExposedClasses::ConstElement elem = exposed_classes.find(p_type_ref.name);
+		return elem ? &elem.value() : nullptr;
+	}
+
+	bool has_type(const TypeReference &p_type_ref) const {
+		if (builtin_types.find(p_type_ref.name) >= 0) {
+			return true;
+		}
+
+		if (p_type_ref.is_enum) {
+			if (enum_types.find(p_type_ref.name) >= 0) {
+				return true;
+			}
+
+			// Enum not found. Most likely because none of its constants were bound, so it's empty. That's fine. Use int instead.
+			return builtin_types.find(names_cache.int_type);
+		}
+
+		return false;
+	}
+};
+
+bool arg_default_value_is_assignable_to_type(const Context &p_context, const Variant &p_val, const TypeReference &p_arg_type, String *r_err_msg = nullptr) {
+	if (p_arg_type.name == p_context.names_cache.variant_type) {
+		// Variant can take anything
+		return true;
+	}
+
+	switch (p_val.get_type()) {
+		case Variant::NIL:
+			return p_context.find_exposed_class(p_arg_type) ||
+				   p_context.names_cache.is_nullable_type(p_arg_type.name);
+		case Variant::BOOL:
+			return p_arg_type.name == p_context.names_cache.bool_type;
+		case Variant::INT:
+			return p_arg_type.name == p_context.names_cache.int_type ||
+				   p_arg_type.name == p_context.names_cache.float_type ||
+				   p_arg_type.is_enum;
+		case Variant::FLOAT:
+			return p_arg_type.name == p_context.names_cache.float_type;
+		case Variant::STRING:
+		case Variant::STRING_NAME:
+			return p_arg_type.name == p_context.names_cache.string_type ||
+				   p_arg_type.name == p_context.names_cache.string_name_type ||
+				   p_arg_type.name == p_context.names_cache.node_path_type;
+		case Variant::NODE_PATH:
+			return p_arg_type.name == p_context.names_cache.node_path_type;
+		case Variant::TRANSFORM:
+		case Variant::TRANSFORM2D:
+		case Variant::BASIS:
+		case Variant::QUAT:
+		case Variant::PLANE:
+		case Variant::AABB:
+		case Variant::COLOR:
+		case Variant::VECTOR2:
+		case Variant::RECT2:
+		case Variant::VECTOR3:
+		case Variant::_RID:
+		case Variant::ARRAY:
+		case Variant::DICTIONARY:
+		case Variant::PACKED_BYTE_ARRAY:
+		case Variant::PACKED_INT32_ARRAY:
+		case Variant::PACKED_INT64_ARRAY:
+		case Variant::PACKED_FLOAT32_ARRAY:
+		case Variant::PACKED_FLOAT64_ARRAY:
+		case Variant::PACKED_STRING_ARRAY:
+		case Variant::PACKED_VECTOR2_ARRAY:
+		case Variant::PACKED_VECTOR3_ARRAY:
+		case Variant::PACKED_COLOR_ARRAY:
+		case Variant::CALLABLE:
+		case Variant::SIGNAL:
+			return p_arg_type.name == Variant::get_type_name(p_val.get_type());
+		case Variant::OBJECT:
+			return p_context.find_exposed_class(p_arg_type);
+		case Variant::VECTOR2I:
+			return p_arg_type.name == p_context.names_cache.vector2_type ||
+				   p_arg_type.name == Variant::get_type_name(p_val.get_type());
+		case Variant::RECT2I:
+			return p_arg_type.name == p_context.names_cache.rect2_type ||
+				   p_arg_type.name == Variant::get_type_name(p_val.get_type());
+		case Variant::VECTOR3I:
+			return p_arg_type.name == p_context.names_cache.vector3_type ||
+				   p_arg_type.name == Variant::get_type_name(p_val.get_type());
+		default:
+			if (r_err_msg) {
+				*r_err_msg = "Unexpected Variant type: " + itos(p_val.get_type());
+			}
+			break;
+	}
+
+	return false;
 }
 
+void validate_property(const Context &p_context, const ExposedClass &p_class, const PropertyData &p_prop) {
+	const MethodData *setter = p_class.find_method_by_name(p_prop.setter);
+
+	// Search it in base classes too
+	const ExposedClass *top = &p_class;
+	while (!setter && top->base != StringName()) {
+		top = p_context.find_exposed_class(top->base);
+		TEST_FAIL_COND(!top, "Class not found '" + top->base + "'. Inherited by '" + top->name + "'.");
+		setter = top->find_method_by_name(p_prop.setter);
+	}
+
+	const MethodData *getter = p_class.find_method_by_name(p_prop.getter);
+
+	// Search it in base classes too
+	top = &p_class;
+	while (!getter && top->base != StringName()) {
+		top = p_context.find_exposed_class(top->base);
+		TEST_FAIL_COND(!top, "Class not found '" + top->base + "'. Inherited by '" + top->name + "'.");
+		getter = top->find_method_by_name(p_prop.getter);
+	}
+
+	TEST_FAIL_COND((!setter && !getter),
+			"Couldn't find neither the setter nor the getter for property: '" + p_class.name + "." + String(p_prop.name) + "'.");
+
+	if (setter) {
+		int setter_argc = p_prop.index != -1 ? 2 : 1;
+		TEST_FAIL_COND(setter->arguments.size() != setter_argc,
+				"Invalid property setter argument count: '" + p_class.name + "." + String(p_prop.name) + "'.");
+	}
+
+	if (getter) {
+		int getter_argc = p_prop.index != -1 ? 1 : 0;
+		TEST_FAIL_COND(getter->arguments.size() != getter_argc,
+				"Invalid property setter argument count: '" + p_class.name + "." + String(p_prop.name) + "'.");
+	}
+
+	if (getter && setter) {
+		const ArgumentData &setter_first_arg = setter->arguments.back()->get();
+		if (getter->return_type.name != setter_first_arg.type.name) {
+			// Special case for Node::set_name
+			bool whitelisted = getter->return_type.name == p_context.names_cache.string_name_type &&
+							   setter_first_arg.type.name == p_context.names_cache.string_type;
+
+			TEST_FAIL_COND(!whitelisted,
+					"Return type from getter doesn't match first argument of setter, for property: '" + p_class.name + "." + String(p_prop.name) + "'.");
+		}
+	}
+
+	const TypeReference &prop_type_ref = getter ? getter->return_type : setter->arguments.back()->get().type;
+
+	const ExposedClass *prop_class = p_context.find_exposed_class(prop_type_ref);
+	if (prop_class) {
+		TEST_COND(prop_class->is_singleton,
+				"Property type is a singleton: '" + p_class.name + "." + String(p_prop.name) + "'.");
+	} else {
+		TEST_FAIL_COND(!p_context.has_type(prop_type_ref),
+				"Property type '" + prop_type_ref.name + "' not found: '" + p_class.name + "." + String(p_prop.name) + "'.");
+	}
+
+	if (getter) {
+		if (p_prop.index != -1) {
+			const ArgumentData &idx_arg = getter->arguments.front()->get();
+			if (idx_arg.type.name != p_context.names_cache.int_type) {
+				// If not an int, it can be an enum
+				TEST_COND(p_context.enum_types.find(idx_arg.type.name) < 0,
+						"Invalid type '" + idx_arg.type.name + "' for index argument of property getter: '" + p_class.name + "." + String(p_prop.name) + "'.");
+			}
+		}
+	}
+
+	if (setter) {
+		if (p_prop.index != -1) {
+			const ArgumentData &idx_arg = setter->arguments.front()->get();
+			if (idx_arg.type.name != p_context.names_cache.int_type) {
+				// Assume the index parameter is an enum
+				// If not an int, it can be an enum
+				TEST_COND(p_context.enum_types.find(idx_arg.type.name) < 0,
+						"Invalid type '" + idx_arg.type.name + "' for index argument of property setter: '" + p_class.name + "." + String(p_prop.name) + "'.");
+			}
+		}
+	}
+}
+
+void validate_method(const Context &p_context, const ExposedClass &p_class, const MethodData &p_method) {
+	const ExposedClass *return_class = p_context.find_exposed_class(p_method.return_type);
+	if (return_class) {
+		TEST_COND(return_class->is_singleton,
+				"Method return type is a singleton: '" + p_class.name + "." + p_method.name + "'.");
+	}
+
+	for (const List<ArgumentData>::Element *F = p_method.arguments.front(); F; F = F->next()) {
+		const ArgumentData &arg = F->get();
+
+		const ExposedClass *arg_class = p_context.find_exposed_class(arg.type);
+		if (arg_class) {
+			TEST_COND(arg_class->is_singleton,
+					"Argument type is a singleton: '" + arg.name + "' of method '" + p_class.name + "." + p_method.name + "'.");
+		} else {
+			TEST_FAIL_COND(!p_context.has_type(arg.type),
+					"Argument type '" + arg.type.name + "' not found: '" + arg.name + "' of method" + p_class.name + "." + p_method.name + "'.");
+		}
+
+		if (arg.has_defval) {
+			String type_error_msg;
+			bool arg_defval_assignable_to_type = arg_default_value_is_assignable_to_type(p_context, arg.defval, arg.type, &type_error_msg);
+			String err_msg = vformat("Invalid default value for parameter '%s' of method '%s.%s'.", arg.name, p_class.name, p_method.name);
+			if (!type_error_msg.empty()) {
+				err_msg += " " + type_error_msg;
+			}
+			TEST_COND(!arg_defval_assignable_to_type, err_msg.utf8().get_data());
+		}
+	}
+}
+
+void validate_signal(const Context &p_context, const ExposedClass &p_class, const SignalData &p_signal) {
+	for (const List<ArgumentData>::Element *F = p_signal.arguments.front(); F; F = F->next()) {
+		const ArgumentData &arg = F->get();
+
+		const ExposedClass *arg_class = p_context.find_exposed_class(arg.type);
+		if (arg_class) {
+			TEST_COND(arg_class->is_singleton,
+					"Argument class is a singleton: '" + arg.name + "' of signal" + p_class.name + "." + p_signal.name + "'.");
+		} else {
+			TEST_FAIL_COND(!p_context.has_type(arg.type),
+					"Argument type '" + arg.type.name + "' not found: '" + arg.name + "' of signal" + p_class.name + "." + p_signal.name + "'.");
+		}
+	}
+}
+
+void validate_class(const Context &p_context, const ExposedClass &p_exposed_class) {
+	bool is_derived_type = p_exposed_class.base != StringName();
+
+	if (!is_derived_type) {
+		// Asserts about the base Object class
+		TEST_FAIL_COND(p_exposed_class.name != p_context.names_cache.object_class,
+				"Class '" + p_exposed_class.name + "' has no base class.");
+		TEST_FAIL_COND(!p_exposed_class.is_instantiable,
+				"Object class is not instantiable.");
+		TEST_FAIL_COND(p_exposed_class.api_type != ClassDB::API_CORE,
+				"Object class is API is not API_CORE.");
+		TEST_FAIL_COND(p_exposed_class.is_singleton,
+				"Object class is registered as a singleton.");
+	}
+
+	TEST_FAIL_COND((p_exposed_class.is_singleton && p_exposed_class.base != p_context.names_cache.object_class),
+			"Singleton base class '" + String(p_exposed_class.base) + "' is not Object, for class '" + p_exposed_class.name + "'.");
+
+	TEST_FAIL_COND((is_derived_type && !p_context.exposed_classes.has(p_exposed_class.base)),
+			"Base type '" + p_exposed_class.base.operator String() + "' does not exist, for class '" + p_exposed_class.name + "'.");
+
+	for (const List<PropertyData>::Element *F = p_exposed_class.properties.front(); F; F = F->next()) {
+		validate_property(p_context, p_exposed_class, F->get());
+	}
+
+	for (const List<MethodData>::Element *F = p_exposed_class.methods.front(); F; F = F->next()) {
+		validate_method(p_context, p_exposed_class, F->get());
+	}
+
+	for (const List<SignalData>::Element *F = p_exposed_class.signals_.front(); F; F = F->next()) {
+		validate_signal(p_context, p_exposed_class, F->get());
+	}
+}
+
+void add_exposed_classes(Context &r_context) {
+	List<StringName> class_list;
+	ClassDB::get_class_list(&class_list);
+	class_list.sort_custom<StringName::AlphCompare>();
+
+	while (class_list.size()) {
+		StringName class_name = class_list.front()->get();
+
+		ClassDB::APIType api_type = ClassDB::get_api_type(class_name);
+
+		if (api_type == ClassDB::API_NONE) {
+			class_list.pop_front();
+			continue;
+		}
+
+		if (!ClassDB::is_class_exposed(class_name)) {
+			MESSAGE(vformat("Ignoring class '%s' because it's not exposed.", class_name).utf8().get_data());
+			class_list.pop_front();
+			continue;
+		}
+
+		if (!ClassDB::is_class_enabled(class_name)) {
+			MESSAGE(vformat("Ignoring class '%s' because it's not enabled.", class_name).utf8().get_data());
+			class_list.pop_front();
+			continue;
+		}
+
+		ClassDB::ClassInfo *class_info = ClassDB::classes.getptr(class_name);
+
+		ExposedClass exposed_class;
+		exposed_class.name = class_name;
+		exposed_class.api_type = api_type;
+		exposed_class.is_singleton = Engine::get_singleton()->has_singleton(class_name);
+		exposed_class.is_instantiable = class_info->creation_func && !exposed_class.is_singleton;
+		exposed_class.is_reference = ClassDB::is_parent_class(class_name, "Reference");
+		exposed_class.base = ClassDB::get_parent_class(class_name);
+
+		// Add properties
+
+		List<PropertyInfo> property_list;
+		ClassDB::get_property_list(class_name, &property_list, true);
+
+		Map<StringName, StringName> accessor_methods;
+
+		for (const List<PropertyInfo>::Element *E = property_list.front(); E; E = E->next()) {
+			const PropertyInfo &property = E->get();
+
+			if (property.usage & PROPERTY_USAGE_GROUP || property.usage & PROPERTY_USAGE_SUBGROUP || property.usage & PROPERTY_USAGE_CATEGORY) {
+				continue;
+			}
+
+			PropertyData prop;
+			prop.name = property.name;
+			prop.setter = ClassDB::get_property_setter(class_name, prop.name);
+			prop.getter = ClassDB::get_property_getter(class_name, prop.name);
+
+			if (prop.setter != StringName()) {
+				accessor_methods[prop.setter] = prop.name;
+			}
+			if (prop.getter != StringName()) {
+				accessor_methods[prop.getter] = prop.name;
+			}
+
+			bool valid = false;
+			prop.index = ClassDB::get_property_index(class_name, prop.name, &valid);
+			TEST_FAIL_COND(!valid, "Invalid property: '" + exposed_class.name + "." + String(prop.name) + "'.");
+
+			exposed_class.properties.push_back(prop);
+		}
+
+		// Add methods
+
+		List<MethodInfo> virtual_method_list;
+		ClassDB::get_virtual_methods(class_name, &virtual_method_list, true);
+
+		List<MethodInfo> method_list;
+		ClassDB::get_method_list(class_name, &method_list, true);
+		method_list.sort();
+
+		for (List<MethodInfo>::Element *E = method_list.front(); E; E = E->next()) {
+			const MethodInfo &method_info = E->get();
+
+			int argc = method_info.arguments.size();
+
+			if (method_info.name.empty()) {
+				continue;
+			}
+
+			MethodData method;
+			method.name = method_info.name;
+
+			if (method_info.flags & METHOD_FLAG_VIRTUAL) {
+				method.is_virtual = true;
+			}
+
+			PropertyInfo return_info = method_info.return_val;
+
+			MethodBind *m = method.is_virtual ? nullptr : ClassDB::get_method(class_name, method_info.name);
+
+			method.is_vararg = m && m->is_vararg();
+
+			if (!m && !method.is_virtual) {
+				TEST_FAIL_COND(!virtual_method_list.find(method_info),
+						"Missing MethodBind for non-virtual method: '" + exposed_class.name + "." + method.name + "'.");
+
+				// A virtual method without the virtual flag. This is a special case.
+
+				// The method Object.free is registered as a virtual method, but without the virtual flag.
+				// This is because this method is not supposed to be overridden, but called.
+				// We assume the return type is void.
+				method.return_type.name = r_context.names_cache.void_type;
+
+				// Actually, more methods like this may be added in the future, which could return
+				// something different. Let's put this check to notify us if that ever happens.
+				String warn_msg = vformat(
+						"Notification: New unexpected virtual non-overridable method found. "
+						"We only expected Object.free, but found '%s.%s'.",
+						exposed_class.name, method.name);
+				TEST_FAIL_COND_WARN(
+						(exposed_class.name != r_context.names_cache.object_class || String(method.name) != "free"),
+						warn_msg.utf8().get_data());
+
+			} else if (return_info.type == Variant::INT && return_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
+				method.return_type.name = return_info.class_name;
+				method.return_type.is_enum = true;
+			} else if (return_info.class_name != StringName()) {
+				method.return_type.name = return_info.class_name;
+
+				bool bad_reference_hint = !method.is_virtual && return_info.hint != PROPERTY_HINT_RESOURCE_TYPE &&
+										  ClassDB::is_parent_class(return_info.class_name, r_context.names_cache.reference_class);
+				TEST_COND(bad_reference_hint, String() + "Return type is reference but hint is not '" _STR(PROPERTY_HINT_RESOURCE_TYPE) "'." +
+													  " Are you returning a reference type by pointer? Method: '" +
+													  exposed_class.name + "." + method.name + "'.");
+			} else if (return_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+				method.return_type.name = return_info.hint_string;
+			} else if (return_info.type == Variant::NIL && return_info.usage & PROPERTY_USAGE_NIL_IS_VARIANT) {
+				method.return_type.name = r_context.names_cache.variant_type;
+			} else if (return_info.type == Variant::NIL) {
+				method.return_type.name = r_context.names_cache.void_type;
+			} else {
+				// NOTE: We don't care about the size and sign of int and float in these tests
+				method.return_type.name = Variant::get_type_name(return_info.type);
+			}
+
+			for (int i = 0; i < argc; i++) {
+				PropertyInfo arg_info = method_info.arguments[i];
+
+				String orig_arg_name = arg_info.name;
+
+				ArgumentData arg;
+				arg.name = orig_arg_name;
+
+				if (arg_info.type == Variant::INT && arg_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
+					arg.type.name = arg_info.class_name;
+					arg.type.is_enum = true;
+				} else if (arg_info.class_name != StringName()) {
+					arg.type.name = arg_info.class_name;
+				} else if (arg_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+					arg.type.name = arg_info.hint_string;
+				} else if (arg_info.type == Variant::NIL) {
+					arg.type.name = r_context.names_cache.variant_type;
+				} else {
+					// NOTE: We don't care about the size and sign of int and float in these tests
+					arg.type.name = Variant::get_type_name(arg_info.type);
+				}
+
+				if (m && m->has_default_argument(i)) {
+					arg.has_defval = true;
+					arg.defval = m->get_default_argument(i);
+				}
+
+				method.arguments.push_back(arg);
+			}
+
+			if (method.is_vararg) {
+				ArgumentData vararg;
+				vararg.type.name = r_context.names_cache.vararg_stub_type;
+				vararg.name = "@varargs@";
+				method.arguments.push_back(vararg);
+			}
+
+			TEST_COND(exposed_class.find_property_by_name(method.name),
+					"Method name conflicts with property: '" + String(class_name) + "." + String(method.name) + "'.");
+
+			// Classes starting with an underscore are ignored unless they're used as a property setter or getter
+			if (!method.is_virtual && String(method.name)[0] == '_') {
+				for (const List<PropertyData>::Element *F = exposed_class.properties.front(); F; F = F->next()) {
+					const PropertyData &prop = F->get();
+
+					if (prop.setter == method.name || prop.getter == method.name) {
+						exposed_class.methods.push_back(method);
+						break;
+					}
+				}
+			} else {
+				exposed_class.methods.push_back(method);
+			}
+		}
+
+		// Add signals
+
+		const HashMap<StringName, MethodInfo> &signal_map = class_info->signal_map;
+		const StringName *k = nullptr;
+
+		while ((k = signal_map.next(k))) {
+			SignalData signal;
+
+			const MethodInfo &method_info = signal_map.get(*k);
+
+			signal.name = method_info.name;
+
+			int argc = method_info.arguments.size();
+
+			for (int i = 0; i < argc; i++) {
+				PropertyInfo arg_info = method_info.arguments[i];
+
+				String orig_arg_name = arg_info.name;
+
+				ArgumentData arg;
+				arg.name = orig_arg_name;
+
+				if (arg_info.type == Variant::INT && arg_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
+					arg.type.name = arg_info.class_name;
+					arg.type.is_enum = true;
+				} else if (arg_info.class_name != StringName()) {
+					arg.type.name = arg_info.class_name;
+				} else if (arg_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+					arg.type.name = arg_info.hint_string;
+				} else if (arg_info.type == Variant::NIL) {
+					arg.type.name = r_context.names_cache.variant_type;
+				} else {
+					// NOTE: We don't care about the size and sign of int and float in these tests
+					arg.type.name = Variant::get_type_name(arg_info.type);
+				}
+
+				signal.arguments.push_back(arg);
+			}
+
+			bool method_conflict = exposed_class.find_property_by_name(signal.name);
+
+			// TODO:
+			// ClassDB allows signal names that conflict with method or property names.
+			// However registering a signal with a conflicting name is still considered wrong.
+			// Unfortunately there are some existing cases that are yet to be fixed.
+			// Until those are fixed we will print a warning instead of failing the test.
+			String warn_msg = vformat(
+					"Signal name conflicts with %s: '%s.%s.",
+					method_conflict ? "method" : "property", class_name, signal.name);
+			TEST_FAIL_COND_WARN((method_conflict || exposed_class.find_method_by_name(signal.name)),
+					warn_msg.utf8().get_data());
+
+			exposed_class.signals_.push_back(signal);
+		}
+
+		// Add enums and constants
+
+		List<String> constants;
+		ClassDB::get_integer_constant_list(class_name, &constants, true);
+
+		const HashMap<StringName, List<StringName>> &enum_map = class_info->enum_map;
+		k = nullptr;
+
+		while ((k = enum_map.next(k))) {
+			EnumData enum_;
+			enum_.name = *k;
+
+			const List<StringName> &enum_constants = enum_map.get(*k);
+			for (const List<StringName>::Element *E = enum_constants.front(); E; E = E->next()) {
+				const StringName &constant_name = E->get();
+				int *value = class_info->constant_map.getptr(constant_name);
+				TEST_FAIL_COND(!value, "Missing enum constant value: '" +
+											   String(class_name) + "." + String(enum_.name) + "." + String(constant_name) + "'.");
+				constants.erase(constant_name);
+
+				ConstantData constant;
+				constant.name = constant_name;
+				constant.value = *value;
+
+				enum_.constants.push_back(constant);
+			}
+
+			exposed_class.enums.push_back(enum_);
+
+			r_context.enum_types.push_back(String(class_name) + "." + String(*k));
+		}
+
+		for (const List<String>::Element *E = constants.front(); E; E = E->next()) {
+			const String &constant_name = E->get();
+			int *value = class_info->constant_map.getptr(StringName(E->get()));
+			TEST_FAIL_COND(!value, "Missing enum constant value: '" + String(class_name) + "." + String(constant_name) + "'.");
+
+			ConstantData constant;
+			constant.name = constant_name;
+			constant.value = *value;
+
+			exposed_class.constants.push_back(constant);
+		}
+
+		r_context.exposed_classes.insert(class_name, exposed_class);
+		class_list.pop_front();
+	}
+}
+
+void add_builtin_types(Context &r_context) {
+	// NOTE: We don't care about the size and sign of int and float in these tests
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		r_context.builtin_types.push_back(Variant::get_type_name(Variant::Type(i)));
+	}
+
+	r_context.builtin_types.push_back(_STR(Variant));
+	r_context.builtin_types.push_back(r_context.names_cache.vararg_stub_type);
+	r_context.builtin_types.push_back("void");
+}
+
+void add_global_enums(Context &r_context) {
+	int global_constants_count = GlobalConstants::get_global_constant_count();
+
+	if (global_constants_count > 0) {
+		for (int i = 0; i < global_constants_count; i++) {
+			StringName enum_name = GlobalConstants::get_global_constant_enum(i);
+
+			if (enum_name != StringName()) {
+				ConstantData constant;
+				constant.name = GlobalConstants::get_global_constant_name(i);
+				constant.value = GlobalConstants::get_global_constant_value(i);
+
+				EnumData enum_;
+				enum_.name = enum_name;
+				List<EnumData>::Element *enum_match = r_context.global_enums.find(enum_);
+				if (enum_match) {
+					enum_match->get().constants.push_back(constant);
+				} else {
+					enum_.constants.push_back(constant);
+					r_context.global_enums.push_back(enum_);
+				}
+			}
+		}
+
+		for (List<EnumData>::Element *E = r_context.global_enums.front(); E; E = E->next()) {
+			r_context.enum_types.push_back(E->get().name);
+		}
+	}
+
+	// HARDCODED
+	List<StringName> hardcoded_enums;
+	hardcoded_enums.push_back("Vector2.Axis");
+	hardcoded_enums.push_back("Vector2i.Axis");
+	hardcoded_enums.push_back("Vector3.Axis");
+	hardcoded_enums.push_back("Vector3i.Axis");
+	for (List<StringName>::Element *E = hardcoded_enums.front(); E; E = E->next()) {
+		// These enums are not generated and must be written manually (e.g.: Vector3.Axis)
+		// Here, we assume core types do not begin with underscore
+		r_context.enum_types.push_back(E->get());
+	}
+}
+
+TEST_SUITE("[ClassDB]") {
+	TEST_CASE("[ClassDB] Add exposed classes, builtin types, and global enums") {
+		Context context;
+
+		add_exposed_classes(context);
+		add_builtin_types(context);
+		add_global_enums(context);
+
+		SUBCASE("[ClassDB] Find exposed class") {
+			const ExposedClass *object_class = context.find_exposed_class(context.names_cache.object_class);
+			TEST_FAIL_COND(!object_class, "Object class not found.");
+			TEST_FAIL_COND(object_class->base != StringName(),
+					"Object class derives from another class: '" + object_class->base + "'.");
+
+			for (ExposedClasses::Element E = context.exposed_classes.front(); E; E = E.next()) {
+				validate_class(context, E.value());
+			}
+		}
+	}
+}
+
+} // namespace TestClassDB
+
 #endif //GODOT_TEST_CLASS_DB_H

tests/test_validate_testing.h

@@ -54,8 +54,6 @@ TEST_SUITE("Validate tests") {
 		CHECK_MESSAGE(_print_error_enabled, "Error printing should be re-enabled.");
 	}
 	TEST_CASE("Stringify Variant types") {
-		ClassDB::init(); // For objects.
-
 		Variant var;
 		INFO(var);
 
@@ -185,8 +183,6 @@ TEST_SUITE("Validate tests") {
 				<< var << " " << vec2 << " " << rect2 << " " << color);
 
 		CHECK(true); // So all above prints.
-
-		ClassDB::cleanup();
 	}
 }