summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.github/workflows/linux_builds.yml61
-rw-r--r--main/main.cpp86
-rw-r--r--main/main.h6
-rw-r--r--modules/mobile_vr/register_types.cpp8
-rw-r--r--platform/linuxbsd/os_linuxbsd.cpp4
-rw-r--r--platform/linuxbsd/os_linuxbsd.h2
-rw-r--r--platform/osx/os_osx.h2
-rw-r--r--platform/osx/os_osx.mm4
-rw-r--r--scene/register_scene_types.cpp12
-rw-r--r--tests/test_class_db.cpp882
-rw-r--r--tests/test_class_db.h798
-rw-r--r--tests/test_validate_testing.h4
12 files changed, 966 insertions, 903 deletions
diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml
index 85ae6a5a8f..087b2d15de 100644
--- a/.github/workflows/linux_builds.yml
+++ b/.github/workflows/linux_builds.yml
@@ -68,6 +68,67 @@ jobs:
run: |
./bin/godot.linuxbsd.opt.tools.64.mono --test
+ linux-editor-sanitizers:
+ runs-on: "ubuntu-20.04"
+ name: Editor with sanitizers (target=debug, tools=yes, tests=yes, use_asan=yes, use_ubsan=yes)
+
+ steps:
+ - uses: actions/checkout@v2
+
+ # Azure repositories are not reliable, we need to prevent azure giving us packages.
+ - name: Make apt sources.list use the default Ubuntu repositories
+ run: |
+ sudo rm -f /etc/apt/sources.list.d/*
+ sudo cp -f misc/ci/sources.list /etc/apt/sources.list
+ sudo apt-get update
+
+ # Install all packages (except scons)
+ - name: Configure dependencies
+ run: |
+ sudo apt-get install build-essential pkg-config libx11-dev libxcursor-dev \
+ libxinerama-dev libgl1-mesa-dev libglu-dev libasound2-dev libpulse-dev libudev-dev libxi-dev libxrandr-dev yasm
+
+ # Upload cache on completion and check it out now
+ - name: Load .scons_cache directory
+ id: linux-editor-cache
+ uses: actions/cache@v2
+ with:
+ path: ${{github.workspace}}/.scons_cache/
+ key: ${{github.job}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
+ restore-keys: |
+ ${{github.job}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
+ ${{github.job}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}
+ ${{github.job}}-${{env.GODOT_BASE_BRANCH}}
+
+ # Use python 3.x release (works cross platform; best to keep self contained in it's own step)
+ - name: Set up Python 3.x
+ uses: actions/setup-python@v2
+ with:
+ # Semantic version range syntax or exact version of a Python version
+ python-version: '3.x'
+ # Optional - x64 or x86 architecture, defaults to x64
+ architecture: 'x64'
+
+ # Setup scons, print python version and scons version info, so if anything is broken it won't run the build.
+ - name: Configuring Python packages
+ run: |
+ python -c "import sys; print(sys.version)"
+ python -m pip install scons
+ python --version
+ scons --version
+
+ # We should always be explicit with our flags usage here since it's gonna be sure to always set those flags
+ - name: Compilation
+ env:
+ SCONS_CACHE: ${{github.workspace}}/.scons_cache/
+ run: |
+ scons -j2 verbose=yes warnings=all werror=yes platform=linuxbsd tools=yes tests=yes target=debug use_asan=yes use_ubsan=yes
+
+ # Execute unit tests for the editor
+ - name: Unit Tests
+ run: |
+ ./bin/godot.linuxbsd.tools.64s --test
+
linux-template:
runs-on: "ubuntu-20.04"
name: Template w/ Mono (target=release, tools=no)
diff --git a/main/main.cpp b/main/main.cpp
index 1c02fcf939..e45162c0f3 100644
--- a/main/main.cpp
+++ b/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;
}
}
diff --git a/main/main.h b/main/main.h
index 20c0bebefa..75a1c0d8cd 100644
--- a/main/main.h
+++ b/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); \
diff --git a/modules/mobile_vr/register_types.cpp b/modules/mobile_vr/register_types.cpp
index 75638d47c4..0bb555e780 100644
--- a/modules/mobile_vr/register_types.cpp
+++ b/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() {
diff --git a/platform/linuxbsd/os_linuxbsd.cpp b/platform/linuxbsd/os_linuxbsd.cpp
index 8c6f3b1167..e00a32e3ba 100644
--- a/platform/linuxbsd/os_linuxbsd.cpp
+++ b/platform/linuxbsd/os_linuxbsd.cpp
@@ -88,7 +88,9 @@ void OS_LinuxBSD::finalize() {
#endif
#ifdef JOYDEV_ENABLED
- memdelete(joypad);
+ if (joypad) {
+ memdelete(joypad);
+ }
#endif
}
diff --git a/platform/linuxbsd/os_linuxbsd.h b/platform/linuxbsd/os_linuxbsd.h
index 4295721c68..cd4fbd9db5 100644
--- a/platform/linuxbsd/os_linuxbsd.h
+++ b/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
diff --git a/platform/osx/os_osx.h b/platform/osx/os_osx.h
index 9204a145bf..5a9e43450f 100644
--- a/platform/osx/os_osx.h
+++ b/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;
diff --git a/platform/osx/os_osx.mm b/platform/osx/os_osx.mm
index c4eb5407af..399a29cbe0 100644
--- a/platform/osx/os_osx.mm
+++ b/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) {
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index 47b8b6073b..996d249bbf 100644
--- a/scene/register_scene_types.cpp
+++ b/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);
diff --git a/tests/test_class_db.cpp b/tests/test_class_db.cpp
deleted file mode 100644
index 3171091402..0000000000
--- a/tests/test_class_db.cpp
+++ /dev/null
@@ -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
diff --git a/tests/test_class_db.h b/tests/test_class_db.h
index 1a31cfb01b..d0d8136874 100644
--- a/tests/test_class_db.h
+++ b/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
diff --git a/tests/test_validate_testing.h b/tests/test_validate_testing.h
index 4bcc57d9c5..b4ea6eb576 100644
--- a/tests/test_validate_testing.h
+++ b/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();
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-27 04:19:26 +0000