64 files changed, 1204 insertions, 390 deletions

diff --git a/tests/SCsub b/tests/SCsub
index 0f3c14f0bd..31466fffc1 100644
--- a/tests/SCsub
+++ b/tests/SCsub
@@ -22,6 +22,11 @@ if env_tests["platform"] == "windows":
 if env_tests.msvc:
     env_tests.Append(CCFLAGS=["/bigobj"])
 
+env_tests.add_source_files(env.tests_sources, "core/*.cpp")
+env_tests.add_source_files(env.tests_sources, "core/math/*.cpp")
+env_tests.add_source_files(env.tests_sources, "core/templates/*.cpp")
+env_tests.add_source_files(env.tests_sources, "scene/*.cpp")
+env_tests.add_source_files(env.tests_sources, "servers/*.cpp")
 env_tests.add_source_files(env.tests_sources, "*.cpp")
 
 lib = env_tests.add_library("tests", env.tests_sources)
diff --git a/tests/test_config_file.h b/tests/core/io/test_config_file.h
index e3f40e16fd..f6fbaf9a88 100644
--- a/tests/test_config_file.h
+++ b/tests/core/io/test_config_file.h
@@ -32,6 +32,7 @@
 #define TEST_CONFIG_FILE_H
 
 #include "core/io/config_file.h"
+#include "core/os/os.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_file_access.h b/tests/core/io/test_file_access.h
index b3da16c1d1..4ffc57afe4 100644
--- a/tests/test_file_access.h
+++ b/tests/core/io/test_file_access.h
@@ -32,7 +32,8 @@
 #define TEST_FILE_ACCESS_H
 
 #include "core/io/file_access.h"
-#include "test_utils.h"
+#include "tests/test_macros.h"
+#include "tests/test_utils.h"
 
 namespace TestFileAccess {
 
diff --git a/tests/test_image.h b/tests/core/io/test_image.h
index 99c2a9380d..c4c5f1e18b 100644
--- a/tests/test_image.h
+++ b/tests/core/io/test_image.h
@@ -31,10 +31,10 @@
 #ifndef TEST_IMAGE_H
 #define TEST_IMAGE_H
 
-#include "core/io/file_access_pack.h"
 #include "core/io/image.h"
-#include "test_utils.h"
+#include "core/os/os.h"
 
+#include "tests/test_utils.h"
 #include "thirdparty/doctest/doctest.h"
 
 namespace TestImage {
diff --git a/tests/test_json.h b/tests/core/io/test_json.h
index 3af58dfa1c..3af58dfa1c 100644
--- a/tests/test_json.h
+++ b/tests/core/io/test_json.h
diff --git a/tests/test_marshalls.h b/tests/core/io/test_marshalls.h
index 6bd916164e..6bd916164e 100644
--- a/tests/test_marshalls.h
+++ b/tests/core/io/test_marshalls.h
diff --git a/tests/test_pck_packer.h b/tests/core/io/test_pck_packer.h
index 06e4e64963..ae51d58522 100644
--- a/tests/test_pck_packer.h
+++ b/tests/core/io/test_pck_packer.h
@@ -35,6 +35,7 @@
 #include "core/io/pck_packer.h"
 #include "core/os/os.h"
 
+#include "tests/test_utils.h"
 #include "thirdparty/doctest/doctest.h"
 
 namespace TestPCKPacker {
diff --git a/tests/test_resource.h b/tests/core/io/test_resource.h
index cee3281995..cee3281995 100644
--- a/tests/test_resource.h
+++ b/tests/core/io/test_resource.h
diff --git a/tests/test_xml_parser.h b/tests/core/io/test_xml_parser.h
index 55de048d6a..2d00f29ddf 100644
--- a/tests/test_xml_parser.h
+++ b/tests/core/io/test_xml_parser.h
@@ -31,10 +31,7 @@
 #ifndef TEST_XML_PARSER_H
 #define TEST_XML_PARSER_H
 
-#include <inttypes.h>
-
 #include "core/io/xml_parser.h"
-#include "core/string/ustring.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_aabb.h b/tests/core/math/test_aabb.h
index 2724d9481a..b838bed171 100644
--- a/tests/test_aabb.h
+++ b/tests/core/math/test_aabb.h
@@ -32,10 +32,8 @@
 #define TEST_AABB_H
 
 #include "core/math/aabb.h"
-#include "core/string/print_string.h"
-#include "tests/test_macros.h"
 
-#include "thirdparty/doctest/doctest.h"
+#include "tests/test_macros.h"
 
 namespace TestAABB {
 
@@ -90,38 +88,38 @@ TEST_CASE("[AABB] Basic setters") {
 			"set_size() should result in the expected AABB.");
 }
 
-TEST_CASE("[AABB] Area getters") {
+TEST_CASE("[AABB] Volume getters") {
 	AABB aabb = AABB(Vector3(-1.5, 2, -2.5), Vector3(4, 5, 6));
 	CHECK_MESSAGE(
-			Math::is_equal_approx(aabb.get_area(), 120),
-			"get_area() should return the expected value with positive size.");
+			Math::is_equal_approx(aabb.get_volume(), 120),
+			"get_volume() should return the expected value with positive size.");
 	CHECK_MESSAGE(
-			!aabb.has_no_area(),
-			"Non-empty volumetric AABB should have an area.");
+			!aabb.has_no_volume(),
+			"Non-empty volumetric AABB should have a volume.");
 
 	aabb = AABB(Vector3(-1.5, 2, -2.5), Vector3(-4, 5, 6));
 	CHECK_MESSAGE(
-			Math::is_equal_approx(aabb.get_area(), -120),
-			"get_area() should return the expected value with negative size (1 component).");
+			Math::is_equal_approx(aabb.get_volume(), -120),
+			"get_volume() should return the expected value with negative size (1 component).");
 
 	aabb = AABB(Vector3(-1.5, 2, -2.5), Vector3(-4, -5, 6));
 	CHECK_MESSAGE(
-			Math::is_equal_approx(aabb.get_area(), 120),
-			"get_area() should return the expected value with negative size (2 components).");
+			Math::is_equal_approx(aabb.get_volume(), 120),
+			"get_volume() should return the expected value with negative size (2 components).");
 
 	aabb = AABB(Vector3(-1.5, 2, -2.5), Vector3(-4, -5, -6));
 	CHECK_MESSAGE(
-			Math::is_equal_approx(aabb.get_area(), -120),
-			"get_area() should return the expected value with negative size (3 components).");
+			Math::is_equal_approx(aabb.get_volume(), -120),
+			"get_volume() should return the expected value with negative size (3 components).");
 
 	aabb = AABB(Vector3(-1.5, 2, -2.5), Vector3(4, 0, 6));
 	CHECK_MESSAGE(
-			aabb.has_no_area(),
-			"Non-empty flat AABB should not have an area.");
+			aabb.has_no_volume(),
+			"Non-empty flat AABB should not have a volume.");
 
 	CHECK_MESSAGE(
-			AABB().has_no_area(),
-			"Empty AABB should not have an area.");
+			AABB().has_no_volume(),
+			"Empty AABB should not have a volume.");
 }
 
 TEST_CASE("[AABB] Surface getters") {
diff --git a/tests/test_astar.h b/tests/core/math/test_astar.h
index 137c477946..2c183374ac 100644
--- a/tests/test_astar.h
+++ b/tests/core/math/test_astar.h
@@ -32,11 +32,6 @@
 #define TEST_ASTAR_H
 
 #include "core/math/a_star.h"
-#include "core/math/math_funcs.h"
-#include "core/os/os.h"
-
-#include <math.h>
-#include <stdio.h>
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_basis.h b/tests/core/math/test_basis.h
index b254d9fb7f..500c069a33 100644
--- a/tests/test_basis.h
+++ b/tests/core/math/test_basis.h
@@ -31,9 +31,8 @@
 #ifndef TEST_BASIS_H
 #define TEST_BASIS_H
 
+#include "core/math/basis.h"
 #include "core/math/random_number_generator.h"
-#include "core/os/os.h"
-#include "core/string/ustring.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_color.h b/tests/core/math/test_color.h
index bffa890ae2..82cf786f7a 100644
--- a/tests/test_color.h
+++ b/tests/core/math/test_color.h
@@ -33,7 +33,7 @@
 
 #include "core/math/color.h"
 
-#include "thirdparty/doctest/doctest.h"
+#include "tests/test_macros.h"
 
 namespace TestColor {
 
diff --git a/tests/test_expression.h b/tests/core/math/test_expression.h
index cb1d29389f..cb1d29389f 100644
--- a/tests/test_expression.h
+++ b/tests/core/math/test_expression.h
diff --git a/tests/test_geometry_2d.h b/tests/core/math/test_geometry_2d.h
index 25af8c355e..8f6669b572 100644
--- a/tests/test_geometry_2d.h
+++ b/tests/core/math/test_geometry_2d.h
@@ -32,7 +32,6 @@
 #define TEST_GEOMETRY_2D_H
 
 #include "core/math/geometry_2d.h"
-#include "core/templates/vector.h"
 
 #include "thirdparty/doctest/doctest.h"
 
diff --git a/tests/test_geometry_3d.h b/tests/core/math/test_geometry_3d.h
index ae30737fe2..f42003ffcf 100644
--- a/tests/test_geometry_3d.h
+++ b/tests/core/math/test_geometry_3d.h
@@ -32,11 +32,7 @@
 #define TEST_GEOMETRY_3D_H
 
 #include "core/math/geometry_3d.h"
-#include "core/math/plane.h"
-#include "core/math/random_number_generator.h"
-#include "core/math/vector3.h"
 #include "tests/test_macros.h"
-#include "vector"
 
 namespace TestGeometry3D {
 TEST_CASE("[Geometry3D] Closest Points Between Segments") {
diff --git a/tests/test_math.cpp b/tests/core/math/test_math.cpp
index 72272382ce..6ec9bc2473 100644
--- a/tests/test_math.cpp
+++ b/tests/core/math/test_math.cpp
@@ -30,23 +30,11 @@
 
 #include "test_math.h"
 
-#include "core/io/file_access.h"
-#include "core/math/basis.h"
 #include "core/math/camera_matrix.h"
 #include "core/math/delaunay_3d.h"
 #include "core/math/geometry_2d.h"
-#include "core/math/math_funcs.h"
-#include "core/math/transform_3d.h"
-#include "core/os/keyboard.h"
+#include "core/os/main_loop.h"
 #include "core/os/os.h"
-#include "core/string/print_string.h"
-#include "core/string/ustring.h"
-#include "core/templates/vmap.h"
-#include "core/variant/method_ptrcall.h"
-#include "core/variant/variant.h"
-#include "scene/main/node.h"
-#include "scene/resources/texture.h"
-#include "servers/rendering/shader_language.h"
 
 namespace TestMath {
 
diff --git a/tests/test_math.h b/tests/core/math/test_math.h
index 4375925bd5..ab5fb6a050 100644
--- a/tests/test_math.h
+++ b/tests/core/math/test_math.h
@@ -31,7 +31,7 @@
 #ifndef TEST_MATH_H
 #define TEST_MATH_H
 
-#include "core/os/main_loop.h"
+class MainLoop;
 
 namespace TestMath {
 
diff --git a/tests/test_random_number_generator.h b/tests/core/math/test_random_number_generator.h
index 39c4771c19..39c4771c19 100644
--- a/tests/test_random_number_generator.h
+++ b/tests/core/math/test_random_number_generator.h
diff --git a/tests/test_rect2.h b/tests/core/math/test_rect2.h
index 3d9fe5a32e..aabb950461 100644
--- a/tests/test_rect2.h
+++ b/tests/core/math/test_rect2.h
@@ -211,26 +211,74 @@ TEST_CASE("[Rect2] Growing") {
 }
 
 TEST_CASE("[Rect2] Has point") {
+	Rect2 rect = Rect2(0, 100, 1280, 720);
 	CHECK_MESSAGE(
-			Rect2(0, 100, 1280, 720).has_point(Vector2(500, 600)),
+			rect.has_point(Vector2(500, 600)),
 			"has_point() with contained Vector2 should return the expected result.");
 	CHECK_MESSAGE(
-			!Rect2(0, 100, 1280, 720).has_point(Vector2(0, 0)),
+			!rect.has_point(Vector2(0, 0)),
 			"has_point() with non-contained Vector2 should return the expected result.");
 
 	CHECK_MESSAGE(
-			Rect2(0, 100, 1280, 720).has_point(Vector2(0, 110)),
-			"has_point() with positive Vector2 on left edge should return the expected result.");
+			rect.has_point(rect.position),
+			"has_point() with positive size should include `position`.");
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + Vector2(1, 1)),
+			"has_point() with positive size should include `position + (1, 1)`.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + Vector2(1, -1)),
+			"has_point() with positive size should not include `position + (1, -1)`.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + rect.size),
+			"has_point() with positive size should not include `position + size`.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + rect.size + Vector2(1, 1)),
+			"has_point() with positive size should not include `position + size + (1, 1)`.");
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + rect.size + Vector2(-1, -1)),
+			"has_point() with positive size should include `position + size + (-1, -1)`.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + rect.size + Vector2(-1, 1)),
+			"has_point() with positive size should not include `position + size + (-1, 1)`.");
+
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + Vector2(0, 10)),
+			"has_point() with point located on left edge should return true.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + Vector2(rect.size.x, 10)),
+			"has_point() with point located on right edge should return false.");
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + Vector2(10, 0)),
+			"has_point() with point located on top edge should return true.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + Vector2(10, rect.size.y)),
+			"has_point() with point located on bottom edge should return false.");
+
+	/*
+	// FIXME: Disabled for now until GH-37617 is fixed one way or another.
+	// More tests should then be written like for the positive size case.
+	rect = Rect2(0, 100, -1280, -720);
+	CHECK_MESSAGE(
+			rect.has_point(rect.position),
+			"has_point() with negative size should include `position`.");
 	CHECK_MESSAGE(
-			!Rect2(0, 100, 1280, 720).has_point(Vector2(1280, 110)),
-			"has_point() with positive Vector2 on right edge should return the expected result.");
+			!rect.has_point(rect.position + rect.size),
+			"has_point() with negative size should not include `position + size`.");
+	*/
 
+	rect = Rect2(-4000, -200, 1280, 720);
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + Vector2(0, 10)),
+			"has_point() with negative position and point located on left edge should return true.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + Vector2(rect.size.x, 10)),
+			"has_point() with negative position and point located on right edge should return false.");
 	CHECK_MESSAGE(
-			Rect2(-4000, 100, 1280, 720).has_point(Vector2(-4000, 110)),
-			"has_point() with negative Vector2 on left edge should return the expected result.");
+			rect.has_point(rect.position + Vector2(10, 0)),
+			"has_point() with negative position and point located on top edge should return true.");
 	CHECK_MESSAGE(
-			!Rect2(-4000, 100, 1280, 720).has_point(Vector2(-2720, 110)),
-			"has_point() with negative Vector2 on right edge should return the expected result.");
+			!rect.has_point(rect.position + Vector2(10, rect.size.y)),
+			"has_point() with negative position and point located on bottom edge should return false.");
 }
 
 TEST_CASE("[Rect2] Intersection") {
@@ -429,26 +477,74 @@ TEST_CASE("[Rect2i] Growing") {
 }
 
 TEST_CASE("[Rect2i] Has point") {
+	Rect2i rect = Rect2i(0, 100, 1280, 720);
 	CHECK_MESSAGE(
-			Rect2i(0, 100, 1280, 720).has_point(Vector2i(500, 600)),
+			rect.has_point(Vector2i(500, 600)),
 			"has_point() with contained Vector2i should return the expected result.");
 	CHECK_MESSAGE(
-			!Rect2i(0, 100, 1280, 720).has_point(Vector2i(0, 0)),
+			!rect.has_point(Vector2i(0, 0)),
 			"has_point() with non-contained Vector2i should return the expected result.");
 
 	CHECK_MESSAGE(
-			Rect2i(0, 100, 1280, 720).has_point(Vector2(0, 110)),
-			"has_point() with positive Vector2 on left edge should return the expected result.");
+			rect.has_point(rect.position),
+			"has_point() with positive size should include `position`.");
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + Vector2i(1, 1)),
+			"has_point() with positive size should include `position + (1, 1)`.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + Vector2i(1, -1)),
+			"has_point() with positive size should not include `position + (1, -1)`.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + rect.size),
+			"has_point() with positive size should not include `position + size`.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + rect.size + Vector2i(1, 1)),
+			"has_point() with positive size should not include `position + size + (1, 1)`.");
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + rect.size + Vector2i(-1, -1)),
+			"has_point() with positive size should include `position + size + (-1, -1)`.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + rect.size + Vector2i(-1, 1)),
+			"has_point() with positive size should not include `position + size + (-1, 1)`.");
+
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + Vector2i(0, 10)),
+			"has_point() with point located on left edge should return true.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + Vector2i(rect.size.x, 10)),
+			"has_point() with point located on right edge should return false.");
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + Vector2i(10, 0)),
+			"has_point() with point located on top edge should return true.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + Vector2i(10, rect.size.y)),
+			"has_point() with point located on bottom edge should return false.");
+
+	/*
+	// FIXME: Disabled for now until GH-37617 is fixed one way or another.
+	// More tests should then be written like for the positive size case.
+	rect = Rect2i(0, 100, -1280, -720);
+	CHECK_MESSAGE(
+			rect.has_point(rect.position),
+			"has_point() with negative size should include `position`.");
 	CHECK_MESSAGE(
-			!Rect2i(0, 100, 1280, 720).has_point(Vector2(1280, 110)),
-			"has_point() with positive Vector2 on right edge should return the expected result.");
+			!rect.has_point(rect.position + rect.size),
+			"has_point() with negative size should not include `position + size`.");
+	*/
 
+	rect = Rect2i(-4000, -200, 1280, 720);
+	CHECK_MESSAGE(
+			rect.has_point(rect.position + Vector2i(0, 10)),
+			"has_point() with negative position and point located on left edge should return true.");
+	CHECK_MESSAGE(
+			!rect.has_point(rect.position + Vector2i(rect.size.x, 10)),
+			"has_point() with negative position and point located on right edge should return false.");
 	CHECK_MESSAGE(
-			Rect2i(-4000, 100, 1280, 720).has_point(Vector2(-4000, 110)),
-			"has_point() with negative Vector2 on left edge should return the expected result.");
+			rect.has_point(rect.position + Vector2i(10, 0)),
+			"has_point() with negative position and point located on top edge should return true.");
 	CHECK_MESSAGE(
-			!Rect2i(-4000, 100, 1280, 720).has_point(Vector2(-2720, 110)),
-			"has_point() with negative Vector2 on right edge should return the expected result.");
+			!rect.has_point(rect.position + Vector2i(10, rect.size.y)),
+			"has_point() with negative position and point located on bottom edge should return false.");
 }
 
 TEST_CASE("[Rect2i] Intersection") {
diff --git a/tests/test_class_db.h b/tests/core/object/test_class_db.h
index 20397bb144..4b27905485 100644
--- a/tests/test_class_db.h
+++ b/tests/core/object/test_class_db.h
@@ -31,14 +31,9 @@
 #ifndef TEST_CLASS_DB_H
 #define TEST_CLASS_DB_H
 
-#include "core/register_core_types.h"
-
+#include "core/core_bind.h"
 #include "core/core_constants.h"
-#include "core/os/os.h"
-#include "core/string/string_name.h"
-#include "core/string/ustring.h"
-#include "core/templates/ordered_hash_map.h"
-#include "core/variant/variant.h"
+#include "core/object/class_db.h"
 
 #include "tests/test_macros.h"
 
@@ -224,20 +219,20 @@ bool arg_default_value_is_assignable_to_type(const Context &p_context, const Var
 	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);
+					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;
+					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;
+					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::TRANSFORM3D:
@@ -269,13 +264,13 @@ bool arg_default_value_is_assignable_to_type(const Context &p_context, const Var
 			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());
+					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());
+					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());
+					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());
@@ -327,7 +322,7 @@ void validate_property(const Context &p_context, const ExposedClass &p_class, co
 		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;
+					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), "'.");
@@ -609,7 +604,7 @@ void add_exposed_classes(Context &r_context) {
 				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.ref_counted_class);
+						ClassDB::is_parent_class(return_info.class_name, r_context.names_cache.ref_counted_class);
 				TEST_COND(bad_reference_hint, "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) {
diff --git a/tests/test_method_bind.h b/tests/core/object/test_method_bind.h
index 879e7949e2..c3a869a8a4 100644
--- a/tests/test_method_bind.h
+++ b/tests/core/object/test_method_bind.h
@@ -35,10 +35,6 @@
 
 #include "tests/test_macros.h"
 
-#include <inttypes.h>
-#include <stdio.h>
-#include <wchar.h>
-
 namespace TestMethodBind {
 
 class MethodBindTester : public Object {
diff --git a/tests/test_object.h b/tests/core/object/test_object.h
index 8cb7116a20..4109ea521a 100644
--- a/tests/test_object.h
+++ b/tests/core/object/test_object.h
@@ -32,9 +32,11 @@
 #define TEST_OBJECT_H
 
 #include "core/core_string_names.h"
+#include "core/object/class_db.h"
 #include "core/object/object.h"
+#include "core/object/script_language.h"
 
-#include "thirdparty/doctest/doctest.h"
+#include "tests/test_macros.h"
 
 // Declared in global namespace because of GDCLASS macro warning (Windows):
 // "Unqualified friend declaration referring to type outside of the nearest enclosing namespace
diff --git a/tests/test_node_path.h b/tests/core/string/test_node_path.h
index f30fe53c5a..0216a30f8f 100644
--- a/tests/test_node_path.h
+++ b/tests/core/string/test_node_path.h
@@ -33,7 +33,7 @@
 
 #include "core/string/node_path.h"
 
-#include "thirdparty/doctest/doctest.h"
+#include "tests/test_macros.h"
 
 namespace TestNodePath {
 
diff --git a/tests/test_string.h b/tests/core/string/test_string.h
index 28d1089d2f..00a9a8779a 100644
--- a/tests/test_string.h
+++ b/tests/core/string/test_string.h
@@ -31,15 +31,7 @@
 #ifndef TEST_STRING_H
 #define TEST_STRING_H
 
-#include <inttypes.h>
-#include <stdio.h>
-#include <wchar.h>
-
-#include "core/io/ip_address.h"
-#include "core/os/main_loop.h"
-#include "core/os/os.h"
 #include "core/string/ustring.h"
-#include "core/variant/variant.h"
 
 #include "tests/test_macros.h"
 
@@ -498,12 +490,6 @@ TEST_CASE("[String] Splitting") {
 	}
 }
 
-TEST_CASE("[String] Erasing") {
-	String s = "Josephine is such a cute girl!";
-	s.erase(s.find("cute "), String("cute ").length());
-	CHECK(s == "Josephine is such a girl!");
-}
-
 struct test_27_data {
 	char const *data;
 	char const *part;
diff --git a/tests/test_translation.h b/tests/core/string/test_translation.h
index 93c53bbbc9..47e06add40 100644
--- a/tests/test_translation.h
+++ b/tests/core/string/test_translation.h
@@ -39,7 +39,8 @@
 #include "editor/import/resource_importer_csv_translation.h"
 #endif
 
-#include "thirdparty/doctest/doctest.h"
+#include "tests/test_macros.h"
+#include "tests/test_utils.h"
 
 namespace TestTranslation {
 
diff --git a/tests/test_command_queue.h b/tests/core/templates/test_command_queue.h
index f0d4569942..5d228f2bf6 100644
--- a/tests/test_command_queue.h
+++ b/tests/core/templates/test_command_queue.h
@@ -33,12 +33,10 @@
 
 #include "core/config/project_settings.h"
 #include "core/math/random_number_generator.h"
-#include "core/os/mutex.h"
 #include "core/os/os.h"
-#include "core/os/semaphore.h"
 #include "core/os/thread.h"
 #include "core/templates/command_queue_mt.h"
-#include "test_macros.h"
+#include "tests/test_macros.h"
 
 #if !defined(NO_THREADS)
 
diff --git a/tests/test_list.h b/tests/core/templates/test_list.h
index 52d5edff70..52d5edff70 100644
--- a/tests/test_list.h
+++ b/tests/core/templates/test_list.h
diff --git a/tests/test_local_vector.h b/tests/core/templates/test_local_vector.h
index eff2a16abc..eff2a16abc 100644
--- a/tests/test_local_vector.h
+++ b/tests/core/templates/test_local_vector.h
diff --git a/tests/test_lru.h b/tests/core/templates/test_lru.h
index 2802754729..9359909c53 100644
--- a/tests/test_lru.h
+++ b/tests/core/templates/test_lru.h
@@ -32,7 +32,6 @@
 #define TEST_LRU_H
 
 #include "core/templates/lru.h"
-#include "core/templates/vector.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_oa_hash_map.cpp b/tests/core/templates/test_oa_hash_map.cpp
index 904c01642d..904c01642d 100644
--- a/tests/test_oa_hash_map.cpp
+++ b/tests/core/templates/test_oa_hash_map.cpp
diff --git a/tests/test_oa_hash_map.h b/tests/core/templates/test_oa_hash_map.h
index 9745802cc0..f229ac94ea 100644
--- a/tests/test_oa_hash_map.h
+++ b/tests/core/templates/test_oa_hash_map.h
@@ -31,7 +31,7 @@
 #ifndef TEST_OA_HASH_MAP_H
 #define TEST_OA_HASH_MAP_H
 
-#include "core/os/main_loop.h"
+class MainLoop;
 
 namespace TestOAHashMap {
 
diff --git a/tests/test_ordered_hash_map.h b/tests/core/templates/test_ordered_hash_map.h
index fbaaa224cf..35ce0fc656 100644
--- a/tests/test_ordered_hash_map.h
+++ b/tests/core/templates/test_ordered_hash_map.h
@@ -31,10 +31,7 @@
 #ifndef TEST_ORDERED_HASH_MAP_H
 #define TEST_ORDERED_HASH_MAP_H
 
-#include "core/os/os.h"
 #include "core/templates/ordered_hash_map.h"
-#include "core/templates/pair.h"
-#include "core/templates/vector.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_paged_array.h b/tests/core/templates/test_paged_array.h
index 7efd3799f3..7efd3799f3 100644
--- a/tests/test_paged_array.h
+++ b/tests/core/templates/test_paged_array.h
diff --git a/tests/test_vector.h b/tests/core/templates/test_vector.h
index bfdf389aa7..bfdf389aa7 100644
--- a/tests/test_vector.h
+++ b/tests/core/templates/test_vector.h
diff --git a/tests/test_crypto.h b/tests/core/test_crypto.h
index 8da8c75544..3b909c7df8 100644
--- a/tests/test_crypto.h
+++ b/tests/core/test_crypto.h
@@ -33,7 +33,6 @@
 
 #include "core/crypto/crypto.h"
 #include "tests/test_macros.h"
-#include <stdio.h>
 
 namespace TestCrypto {
 
diff --git a/tests/test_hashing_context.h b/tests/core/test_hashing_context.h
index 728a5f2cfa..728a5f2cfa 100644
--- a/tests/test_hashing_context.h
+++ b/tests/core/test_hashing_context.h
diff --git a/tests/test_time.h b/tests/core/test_time.h
index 28f1cb2f20..28f1cb2f20 100644
--- a/tests/test_time.h
+++ b/tests/core/test_time.h
diff --git a/tests/test_array.h b/tests/core/variant/test_array.h
index 3bd476fd27..298bd2ff63 100644
--- a/tests/test_array.h
+++ b/tests/core/variant/test_array.h
@@ -31,18 +31,31 @@
 #ifndef TEST_ARRAY_H
 #define TEST_ARRAY_H
 
-#include "core/object/class_db.h"
-#include "core/object/script_language.h"
-#include "core/templates/hashfuncs.h"
-#include "core/templates/vector.h"
 #include "core/variant/array.h"
-#include "core/variant/container_type_validate.h"
-#include "core/variant/variant.h"
 #include "tests/test_macros.h"
 #include "tests/test_tools.h"
 
 namespace TestArray {
 
+static inline Array build_array() {
+	return Array();
+}
+template <typename... Targs>
+static inline Array build_array(Variant item, Targs... Fargs) {
+	Array a = build_array(Fargs...);
+	a.push_front(item);
+	return a;
+}
+static inline Dictionary build_dictionary() {
+	return Dictionary();
+}
+template <typename... Targs>
+static inline Dictionary build_dictionary(Variant key, Variant item, Targs... Fargs) {
+	Dictionary d = build_dictionary(Fargs...);
+	d[key] = item;
+	return d;
+}
+
 TEST_CASE("[Array] size(), clear(), and is_empty()") {
 	Array arr;
 	CHECK(arr.size() == 0);
@@ -232,6 +245,221 @@ TEST_CASE("[Array] max() and min()") {
 	CHECK(max == 5);
 	CHECK(min == 2);
 }
+
+TEST_CASE("[Array] Duplicate array") {
+	// a = [1, [2, 2], {3: 3}]
+	Array a = build_array(1, build_array(2, 2), build_dictionary(3, 3));
+
+	// Deep copy
+	Array deep_a = a.duplicate(true);
+	CHECK_MESSAGE(deep_a.id() != a.id(), "Should create a new array");
+	CHECK_MESSAGE(Array(deep_a[1]).id() != Array(a[1]).id(), "Should clone nested array");
+	CHECK_MESSAGE(Dictionary(deep_a[2]).id() != Dictionary(a[2]).id(), "Should clone nested dictionary");
+	CHECK_EQ(deep_a, a);
+	deep_a.push_back(1);
+	CHECK_NE(deep_a, a);
+	deep_a.pop_back();
+	Array(deep_a[1]).push_back(1);
+	CHECK_NE(deep_a, a);
+	Array(deep_a[1]).pop_back();
+	CHECK_EQ(deep_a, a);
+
+	// Shallow copy
+	Array shallow_a = a.duplicate(false);
+	CHECK_MESSAGE(shallow_a.id() != a.id(), "Should create a new array");
+	CHECK_MESSAGE(Array(shallow_a[1]).id() == Array(a[1]).id(), "Should keep nested array");
+	CHECK_MESSAGE(Dictionary(shallow_a[2]).id() == Dictionary(a[2]).id(), "Should keep nested dictionary");
+	CHECK_EQ(shallow_a, a);
+	Array(shallow_a).push_back(1);
+	CHECK_NE(shallow_a, a);
+}
+
+TEST_CASE("[Array] Duplicate recursive array") {
+	// Self recursive
+	Array a;
+	a.push_back(a);
+
+	Array a_shallow = a.duplicate(false);
+	CHECK_EQ(a, a_shallow);
+
+	// Deep copy of recursive array endup with recursion limit and return
+	// an invalid result (multiple nested arrays), the point is we should
+	// not end up with a segfault and an error log should be printed
+	ERR_PRINT_OFF;
+	a.duplicate(true);
+	ERR_PRINT_ON;
+
+	// Nested recursive
+	Array a1;
+	Array a2;
+	a2.push_back(a1);
+	a1.push_back(a2);
+
+	Array a1_shallow = a1.duplicate(false);
+	CHECK_EQ(a1, a1_shallow);
+
+	// Same deep copy issue as above
+	ERR_PRINT_OFF;
+	a1.duplicate(true);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Array teardown will leak memory
+	a.clear();
+	a1.clear();
+	a2.clear();
+}
+
+TEST_CASE("[Array] Hash array") {
+	// a = [1, [2, 2], {3: 3}]
+	Array a = build_array(1, build_array(2, 2), build_dictionary(3, 3));
+	uint32_t original_hash = a.hash();
+
+	a.push_back(1);
+	CHECK_NE(a.hash(), original_hash);
+
+	a.pop_back();
+	CHECK_EQ(a.hash(), original_hash);
+
+	Array(a[1]).push_back(1);
+	CHECK_NE(a.hash(), original_hash);
+	Array(a[1]).pop_back();
+	CHECK_EQ(a.hash(), original_hash);
+
+	(Dictionary(a[2]))[1] = 1;
+	CHECK_NE(a.hash(), original_hash);
+	Dictionary(a[2]).erase(1);
+	CHECK_EQ(a.hash(), original_hash);
+
+	Array a2 = a.duplicate(true);
+	CHECK_EQ(a2.hash(), a.hash());
+}
+
+TEST_CASE("[Array] Hash recursive array") {
+	Array a1;
+	a1.push_back(a1);
+
+	Array a2;
+	a2.push_back(a2);
+
+	// Hash should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_EQ(a1.hash(), a2.hash());
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Array teardown will leak memory
+	a1.clear();
+	a2.clear();
+}
+
+TEST_CASE("[Array] Empty comparison") {
+	Array a1;
+	Array a2;
+
+	// test both operator== and operator!=
+	CHECK_EQ(a1, a2);
+	CHECK_FALSE(a1 != a2);
+}
+
+TEST_CASE("[Array] Flat comparison") {
+	Array a1 = build_array(1);
+	Array a2 = build_array(1);
+	Array other_a = build_array(2);
+
+	// test both operator== and operator!=
+	CHECK_EQ(a1, a1); // compare self
+	CHECK_FALSE(a1 != a1);
+	CHECK_EQ(a1, a2); // different equivalent arrays
+	CHECK_FALSE(a1 != a2);
+	CHECK_NE(a1, other_a); // different arrays with different content
+	CHECK_FALSE(a1 == other_a);
+}
+
+TEST_CASE("[Array] Nested array comparison") {
+	// a1 = [[[1], 2], 3]
+	Array a1 = build_array(build_array(build_array(1), 2), 3);
+
+	Array a2 = a1.duplicate(true);
+
+	// other_a = [[[1, 0], 2], 3]
+	Array other_a = build_array(build_array(build_array(1, 0), 2), 3);
+
+	// test both operator== and operator!=
+	CHECK_EQ(a1, a1); // compare self
+	CHECK_FALSE(a1 != a1);
+	CHECK_EQ(a1, a2); // different equivalent arrays
+	CHECK_FALSE(a1 != a2);
+	CHECK_NE(a1, other_a); // different arrays with different content
+	CHECK_FALSE(a1 == other_a);
+}
+
+TEST_CASE("[Array] Nested dictionary comparison") {
+	// a1 = [{1: 2}, 3]
+	Array a1 = build_array(build_dictionary(1, 2), 3);
+
+	Array a2 = a1.duplicate(true);
+
+	// other_a = [{1: 0}, 3]
+	Array other_a = build_array(build_dictionary(1, 0), 3);
+
+	// test both operator== and operator!=
+	CHECK_EQ(a1, a1); // compare self
+	CHECK_FALSE(a1 != a1);
+	CHECK_EQ(a1, a2); // different equivalent arrays
+	CHECK_FALSE(a1 != a2);
+	CHECK_NE(a1, other_a); // different arrays with different content
+	CHECK_FALSE(a1 == other_a);
+}
+
+TEST_CASE("[Array] Recursive comparison") {
+	Array a1;
+	a1.push_back(a1);
+
+	Array a2;
+	a2.push_back(a2);
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_EQ(a1, a2);
+	CHECK_FALSE(a1 != a2);
+	ERR_PRINT_ON;
+
+	a1.push_back(1);
+	a2.push_back(1);
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_EQ(a1, a2);
+	CHECK_FALSE(a1 != a2);
+	ERR_PRINT_ON;
+
+	a1.push_back(1);
+	a2.push_back(2);
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_NE(a1, a2);
+	CHECK_FALSE(a1 == a2);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Array tearndown will leak memory
+	a1.clear();
+	a2.clear();
+}
+
+TEST_CASE("[Array] Recursive self comparison") {
+	Array a1;
+	Array a2;
+	a2.push_back(a1);
+	a1.push_back(a2);
+
+	CHECK_EQ(a1, a1);
+	CHECK_FALSE(a1 != a1);
+
+	// Break the recursivity otherwise Array tearndown will leak memory
+	a1.clear();
+	a2.clear();
+}
+
 } // namespace TestArray
 
 #endif // TEST_ARRAY_H
diff --git a/tests/core/variant/test_dictionary.h b/tests/core/variant/test_dictionary.h
new file mode 100644
index 0000000000..65079698a3
--- /dev/null
+++ b/tests/core/variant/test_dictionary.h
@@ -0,0 +1,505 @@
+/*************************************************************************/
+/*  test_dictionary.h                                                    */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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.                */
+/*************************************************************************/
+
+#ifndef TEST_DICTIONARY_H
+#define TEST_DICTIONARY_H
+
+#include "core/variant/dictionary.h"
+#include "tests/test_macros.h"
+
+namespace TestDictionary {
+
+static inline Array build_array() {
+	return Array();
+}
+template <typename... Targs>
+static inline Array build_array(Variant item, Targs... Fargs) {
+	Array a = build_array(Fargs...);
+	a.push_front(item);
+	return a;
+}
+static inline Dictionary build_dictionary() {
+	return Dictionary();
+}
+template <typename... Targs>
+static inline Dictionary build_dictionary(Variant key, Variant item, Targs... Fargs) {
+	Dictionary d = build_dictionary(Fargs...);
+	d[key] = item;
+	return d;
+}
+
+TEST_CASE("[Dictionary] Assignment using bracket notation ([])") {
+	Dictionary map;
+	map["Hello"] = 0;
+	CHECK(int(map["Hello"]) == 0);
+	map["Hello"] = 3;
+	CHECK(int(map["Hello"]) == 3);
+	map["World!"] = 4;
+	CHECK(int(map["World!"]) == 4);
+
+	// Test non-string keys, since keys can be of any Variant type.
+	map[12345] = -5;
+	CHECK(int(map[12345]) == -5);
+	map[false] = 128;
+	CHECK(int(map[false]) == 128);
+	map[Vector2(10, 20)] = 30;
+	CHECK(int(map[Vector2(10, 20)]) == 30);
+	map[0] = 400;
+	CHECK(int(map[0]) == 400);
+	// Check that assigning 0 doesn't overwrite the value for `false`.
+	CHECK(int(map[false]) == 128);
+}
+
+TEST_CASE("[Dictionary] get_key_lists()") {
+	Dictionary map;
+	List<Variant> keys;
+	List<Variant> *ptr = &keys;
+	map.get_key_list(ptr);
+	CHECK(keys.is_empty());
+	map[1] = 3;
+	map.get_key_list(ptr);
+	CHECK(keys.size() == 1);
+	CHECK(int(keys[0]) == 1);
+	map[2] = 4;
+	map.get_key_list(ptr);
+	CHECK(keys.size() == 3);
+}
+
+TEST_CASE("[Dictionary] get_key_at_index()") {
+	Dictionary map;
+	map[4] = 3;
+	Variant val = map.get_key_at_index(0);
+	CHECK(int(val) == 4);
+	map[3] = 1;
+	val = map.get_key_at_index(0);
+	CHECK(int(val) == 4);
+	val = map.get_key_at_index(1);
+	CHECK(int(val) == 3);
+}
+
+TEST_CASE("[Dictionary] getptr()") {
+	Dictionary map;
+	map[1] = 3;
+	Variant *key = map.getptr(1);
+	CHECK(int(*key) == 3);
+	key = map.getptr(2);
+	CHECK(key == nullptr);
+}
+
+TEST_CASE("[Dictionary] get_valid()") {
+	Dictionary map;
+	map[1] = 3;
+	Variant val = map.get_valid(1);
+	CHECK(int(val) == 3);
+}
+TEST_CASE("[Dictionary] get()") {
+	Dictionary map;
+	map[1] = 3;
+	Variant val = map.get(1, -1);
+	CHECK(int(val) == 3);
+}
+
+TEST_CASE("[Dictionary] size(), empty() and clear()") {
+	Dictionary map;
+	CHECK(map.size() == 0);
+	CHECK(map.is_empty());
+	map[1] = 3;
+	CHECK(map.size() == 1);
+	CHECK(!map.is_empty());
+	map.clear();
+	CHECK(map.size() == 0);
+	CHECK(map.is_empty());
+}
+
+TEST_CASE("[Dictionary] has() and has_all()") {
+	Dictionary map;
+	CHECK(map.has(1) == false);
+	map[1] = 3;
+	CHECK(map.has(1));
+	Array keys;
+	keys.push_back(1);
+	CHECK(map.has_all(keys));
+	keys.push_back(2);
+	CHECK(map.has_all(keys) == false);
+}
+
+TEST_CASE("[Dictionary] keys() and values()") {
+	Dictionary map;
+	Array keys = map.keys();
+	Array values = map.values();
+	CHECK(keys.is_empty());
+	CHECK(values.is_empty());
+	map[1] = 3;
+	keys = map.keys();
+	values = map.values();
+	CHECK(int(keys[0]) == 1);
+	CHECK(int(values[0]) == 3);
+}
+
+TEST_CASE("[Dictionary] Duplicate dictionary") {
+	// d = {1: {1: 1}, {2: 2}: [2], [3]: 3}
+	Dictionary k2 = build_dictionary(2, 2);
+	Array k3 = build_array(3);
+	Dictionary d = build_dictionary(1, build_dictionary(1, 1), k2, build_array(2), k3, 3);
+
+	// Deep copy
+	Dictionary deep_d = d.duplicate(true);
+	CHECK_MESSAGE(deep_d.id() != d.id(), "Should create a new dictionary");
+	CHECK_MESSAGE(Dictionary(deep_d[1]).id() != Dictionary(d[1]).id(), "Should clone nested dictionary");
+	CHECK_MESSAGE(Array(deep_d[k2]).id() != Array(d[k2]).id(), "Should clone nested array");
+	CHECK_EQ(deep_d, d);
+	deep_d[0] = 0;
+	CHECK_NE(deep_d, d);
+	deep_d.erase(0);
+	Dictionary(deep_d[1]).operator[](0) = 0;
+	CHECK_NE(deep_d, d);
+	Dictionary(deep_d[1]).erase(0);
+	CHECK_EQ(deep_d, d);
+	// Keys should also be copied
+	k2[0] = 0;
+	CHECK_NE(deep_d, d);
+	k2.erase(0);
+	CHECK_EQ(deep_d, d);
+	k3.push_back(0);
+	CHECK_NE(deep_d, d);
+	k3.pop_back();
+	CHECK_EQ(deep_d, d);
+
+	// Shallow copy
+	Dictionary shallow_d = d.duplicate(false);
+	CHECK_MESSAGE(shallow_d.id() != d.id(), "Should create a new array");
+	CHECK_MESSAGE(Dictionary(shallow_d[1]).id() == Dictionary(d[1]).id(), "Should keep nested dictionary");
+	CHECK_MESSAGE(Array(shallow_d[2]).id() == Array(d[2]).id(), "Should keep nested array");
+	CHECK_EQ(shallow_d, d);
+	shallow_d[0] = 0;
+	CHECK_NE(shallow_d, d);
+	shallow_d.erase(0);
+#if 0 // TODO: recursion in dict key currently is buggy
+	// Keys should also be shallowed
+	k2[0] = 0;
+	CHECK_EQ(shallow_d, d);
+	k2.erase(0);
+	k3.push_back(0);
+	CHECK_EQ(shallow_d, d);
+#endif
+}
+
+TEST_CASE("[Dictionary] Duplicate recursive dictionary") {
+	// Self recursive
+	Dictionary d;
+	d[1] = d;
+
+	Dictionary d_shallow = d.duplicate(false);
+	CHECK_EQ(d, d_shallow);
+
+	// Deep copy of recursive dictionary endup with recursion limit and return
+	// an invalid result (multiple nested dictionaries), the point is we should
+	// not end up with a segfault and an error log should be printed
+	ERR_PRINT_OFF;
+	d.duplicate(true);
+	ERR_PRINT_ON;
+
+	// Nested recursive
+	Dictionary d1;
+	Dictionary d2;
+	d1[2] = d2;
+	d2[1] = d1;
+
+	Dictionary d1_shallow = d1.duplicate(false);
+	CHECK_EQ(d1, d1_shallow);
+
+	// Same deep copy issue as above
+	ERR_PRINT_OFF;
+	d1.duplicate(true);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary teardown will leak memory
+	d.clear();
+	d1.clear();
+	d2.clear();
+}
+
+#if 0 // TODO: duplicate recursion in dict key is currently buggy
+TEST_CASE("[Dictionary] Duplicate recursive dictionary on keys") {
+	// Self recursive
+	Dictionary d;
+	d[d] = d;
+
+	Dictionary d_shallow = d.duplicate(false);
+	CHECK_EQ(d, d_shallow);
+
+	// Deep copy of recursive dictionary endup with recursion limit and return
+	// an invalid result (multiple nested dictionaries), the point is we should
+	// not end up with a segfault and an error log should be printed
+	ERR_PRINT_OFF;
+	d.duplicate(true);
+	ERR_PRINT_ON;
+
+	// Nested recursive
+	Dictionary d1;
+	Dictionary d2;
+	d1[d2] = d2;
+	d2[d1] = d1;
+
+	Dictionary d1_shallow = d1.duplicate(false);
+	CHECK_EQ(d1, d1_shallow);
+
+	// Same deep copy issue as above
+	ERR_PRINT_OFF;
+	d1.duplicate(true);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary teardown will leak memory
+	d.clear();
+	d1.clear();
+	d2.clear();
+}
+#endif
+
+TEST_CASE("[Dictionary] Hash dictionary") {
+	// d = {1: {1: 1}, {2: 2}: [2], [3]: 3}
+	Dictionary k2 = build_dictionary(2, 2);
+	Array k3 = build_array(3);
+	Dictionary d = build_dictionary(1, build_dictionary(1, 1), k2, build_array(2), k3, 3);
+	uint32_t original_hash = d.hash();
+
+	// Modify dict change the hash
+	d[0] = 0;
+	CHECK_NE(d.hash(), original_hash);
+	d.erase(0);
+	CHECK_EQ(d.hash(), original_hash);
+
+	// Modify nested item change the hash
+	Dictionary(d[1]).operator[](0) = 0;
+	CHECK_NE(d.hash(), original_hash);
+	Dictionary(d[1]).erase(0);
+	Array(d[k2]).push_back(0);
+	CHECK_NE(d.hash(), original_hash);
+	Array(d[k2]).pop_back();
+
+	// Modify a key change the hash
+	k2[0] = 0;
+	CHECK_NE(d.hash(), original_hash);
+	k2.erase(0);
+	CHECK_EQ(d.hash(), original_hash);
+	k3.push_back(0);
+	CHECK_NE(d.hash(), original_hash);
+	k3.pop_back();
+	CHECK_EQ(d.hash(), original_hash);
+
+	// Duplication doesn't change the hash
+	Dictionary d2 = d.duplicate(true);
+	CHECK_EQ(d2.hash(), original_hash);
+}
+
+TEST_CASE("[Dictionary] Hash recursive dictionary") {
+	Dictionary d;
+	d[1] = d;
+
+	// Hash should reach recursion limit, we just make sure this doesn't blow up
+	ERR_PRINT_OFF;
+	d.hash();
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary teardown will leak memory
+	d.clear();
+}
+
+#if 0 // TODO: recursion in dict key is currently buggy
+TEST_CASE("[Dictionary] Hash recursive dictionary on keys") {
+	Dictionary d;
+	d[d] = 1;
+
+	// Hash should reach recursion limit, we just make sure this doesn't blow up
+	ERR_PRINT_OFF;
+	d.hash();
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary teardown will leak memory
+	d.clear();
+}
+#endif
+
+TEST_CASE("[Dictionary] Empty comparison") {
+	Dictionary d1;
+	Dictionary d2;
+
+	// test both operator== and operator!=
+	CHECK_EQ(d1, d2);
+	CHECK_FALSE(d1 != d2);
+}
+
+TEST_CASE("[Dictionary] Flat comparison") {
+	Dictionary d1 = build_dictionary(1, 1);
+	Dictionary d2 = build_dictionary(1, 1);
+	Dictionary other_d = build_dictionary(2, 1);
+
+	// test both operator== and operator!=
+	CHECK_EQ(d1, d1); // compare self
+	CHECK_FALSE(d1 != d1);
+	CHECK_EQ(d1, d2); // different equivalent arrays
+	CHECK_FALSE(d1 != d2);
+	CHECK_NE(d1, other_d); // different arrays with different content
+	CHECK_FALSE(d1 == other_d);
+}
+
+TEST_CASE("[Dictionary] Nested dictionary comparison") {
+	// d1 = {1: {2: {3: 4}}}
+	Dictionary d1 = build_dictionary(1, build_dictionary(2, build_dictionary(3, 4)));
+
+	Dictionary d2 = d1.duplicate(true);
+
+	// other_d = {1: {2: {3: 0}}}
+	Dictionary other_d = build_dictionary(1, build_dictionary(2, build_dictionary(3, 0)));
+
+	// test both operator== and operator!=
+	CHECK_EQ(d1, d1); // compare self
+	CHECK_FALSE(d1 != d1);
+	CHECK_EQ(d1, d2); // different equivalent arrays
+	CHECK_FALSE(d1 != d2);
+	CHECK_NE(d1, other_d); // different arrays with different content
+	CHECK_FALSE(d1 == other_d);
+}
+
+TEST_CASE("[Dictionary] Nested array comparison") {
+	// d1 = {1: [2, 3]}
+	Dictionary d1 = build_dictionary(1, build_array(2, 3));
+
+	Dictionary d2 = d1.duplicate(true);
+
+	// other_d = {1: [2, 0]}
+	Dictionary other_d = build_dictionary(1, build_array(2, 0));
+
+	// test both operator== and operator!=
+	CHECK_EQ(d1, d1); // compare self
+	CHECK_FALSE(d1 != d1);
+	CHECK_EQ(d1, d2); // different equivalent arrays
+	CHECK_FALSE(d1 != d2);
+	CHECK_NE(d1, other_d); // different arrays with different content
+	CHECK_FALSE(d1 == other_d);
+}
+
+TEST_CASE("[Dictionary] Recursive comparison") {
+	Dictionary d1;
+	d1[1] = d1;
+
+	Dictionary d2;
+	d2[1] = d2;
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_EQ(d1, d2);
+	CHECK_FALSE(d1 != d2);
+	ERR_PRINT_ON;
+
+	d1[2] = 2;
+	d2[2] = 2;
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_EQ(d1, d2);
+	CHECK_FALSE(d1 != d2);
+	ERR_PRINT_ON;
+
+	d1[3] = 3;
+	d2[3] = 0;
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_NE(d1, d2);
+	CHECK_FALSE(d1 == d2);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary teardown will leak memory
+	d1.clear();
+	d2.clear();
+}
+
+#if 0 // TODO: recursion in dict key is currently buggy
+TEST_CASE("[Dictionary] Recursive comparison on keys") {
+	Dictionary d1;
+	// Hash computation should reach recursion limit
+	ERR_PRINT_OFF;
+	d1[d1] = 1;
+	ERR_PRINT_ON;
+
+	Dictionary d2;
+	// Hash computation should reach recursion limit
+	ERR_PRINT_OFF;
+	d2[d2] = 1;
+	ERR_PRINT_ON;
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_EQ(d1, d2);
+	CHECK_FALSE(d1 != d2);
+	ERR_PRINT_ON;
+
+	d1[2] = 2;
+	d2[2] = 2;
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_EQ(d1, d2);
+	CHECK_FALSE(d1 != d2);
+	ERR_PRINT_ON;
+
+	d1[3] = 3;
+	d2[3] = 0;
+
+	// Comparison should reach recursion limit
+	ERR_PRINT_OFF;
+	CHECK_NE(d1, d2);
+	CHECK_FALSE(d1 == d2);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary teardown will leak memory
+	d1.clear();
+	d2.clear();
+}
+#endif
+
+TEST_CASE("[Dictionary] Recursive self comparison") {
+	Dictionary d1;
+	Dictionary d2;
+	d1[1] = d2;
+	d2[1] = d1;
+
+	CHECK_EQ(d1, d1);
+	CHECK_FALSE(d1 != d1);
+
+	// Break the recursivity otherwise Dictionary teardown will leak memory
+	d1.clear();
+	d2.clear();
+}
+
+} // namespace TestDictionary
+
+#endif // TEST_DICTIONARY_H
diff --git a/tests/test_variant.h b/tests/core/variant/test_variant.h
index 598fe488d7..0d16fa092c 100644
--- a/tests/test_variant.h
+++ b/tests/core/variant/test_variant.h
@@ -38,6 +38,25 @@
 
 namespace TestVariant {
 
+static inline Array build_array() {
+	return Array();
+}
+template <typename... Targs>
+static inline Array build_array(Variant item, Targs... Fargs) {
+	Array a = build_array(Fargs...);
+	a.push_front(item);
+	return a;
+}
+static inline Dictionary build_dictionary() {
+	return Dictionary();
+}
+template <typename... Targs>
+static inline Dictionary build_dictionary(Variant key, Variant item, Targs... Fargs) {
+	Dictionary d = build_dictionary(Fargs...);
+	d[key] = item;
+	return d;
+}
+
 TEST_CASE("[Variant] Writer and parser integer") {
 	int64_t a32 = 2147483648; // 2^31, so out of bounds for 32-bit signed int [-2^31, +2^31-1].
 	String a32_str;
@@ -700,6 +719,198 @@ TEST_CASE("[Variant] Assignment To Color from Bool,Int,Float,String,Vec2,Vec2i,V
 	vec3i_v = col_v;
 	CHECK(vec3i_v.get_type() == Variant::COLOR);
 }
+TEST_CASE("[Variant] Writer and parser array") {
+	Array a = build_array(1, String("hello"), build_array(Variant()));
+	String a_str;
+	VariantWriter::write_to_string(a, a_str);
+
+	CHECK_EQ(a_str, "[1, \"hello\", [null]]");
+
+	VariantParser::StreamString ss;
+	String errs;
+	int line;
+	Variant a_parsed;
+
+	ss.s = a_str;
+	VariantParser::parse(&ss, a_parsed, errs, line);
+
+	CHECK_MESSAGE(a_parsed == Variant(a), "Should parse back.");
+}
+
+TEST_CASE("[Variant] Writer recursive array") {
+	// There is no way to accurately represent a recursive array,
+	// the only thing we can do is make sure the writer doesn't blow up
+
+	// Self recursive
+	Array a;
+	a.push_back(a);
+
+	// Writer should it recursion limit while visiting the array
+	ERR_PRINT_OFF;
+	String a_str;
+	VariantWriter::write_to_string(a, a_str);
+	ERR_PRINT_ON;
+
+	// Nested recursive
+	Array a1;
+	Array a2;
+	a1.push_back(a2);
+	a2.push_back(a1);
+
+	// Writer should it recursion limit while visiting the array
+	ERR_PRINT_OFF;
+	String a1_str;
+	VariantWriter::write_to_string(a1, a1_str);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary tearndown will leak memory
+	a.clear();
+	a1.clear();
+	a2.clear();
+}
+
+TEST_CASE("[Variant] Writer and parser dictionary") {
+	// d = {{1: 2}: 3, 4: "hello", 5: {null: []}}
+	Dictionary d = build_dictionary(build_dictionary(1, 2), 3, 4, String("hello"), 5, build_dictionary(Variant(), build_array()));
+	String d_str;
+	VariantWriter::write_to_string(d, d_str);
+
+	CHECK_EQ(d_str, "{\n4: \"hello\",\n5: {\nnull: []\n},\n{\n1: 2\n}: 3\n}");
+
+	VariantParser::StreamString ss;
+	String errs;
+	int line;
+	Variant d_parsed;
+
+	ss.s = d_str;
+	VariantParser::parse(&ss, d_parsed, errs, line);
+
+	CHECK_MESSAGE(d_parsed == Variant(d), "Should parse back.");
+}
+
+TEST_CASE("[Variant] Writer recursive dictionary") {
+	// There is no way to accurately represent a recursive dictionary,
+	// the only thing we can do is make sure the writer doesn't blow up
+
+	// Self recursive
+	Dictionary d;
+	d[1] = d;
+
+	// Writer should it recursion limit while visiting the dictionary
+	ERR_PRINT_OFF;
+	String d_str;
+	VariantWriter::write_to_string(d, d_str);
+	ERR_PRINT_ON;
+
+	// Nested recursive
+	Dictionary d1;
+	Dictionary d2;
+	d1[2] = d2;
+	d2[1] = d1;
+
+	// Writer should it recursion limit while visiting the dictionary
+	ERR_PRINT_OFF;
+	String d1_str;
+	VariantWriter::write_to_string(d1, d1_str);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary tearndown will leak memory
+	d.clear();
+	d1.clear();
+	d2.clear();
+}
+
+#if 0 // TODO: recursion in dict key is currently buggy
+TEST_CASE("[Variant] Writer recursive dictionary on keys") {
+	// There is no way to accurately represent a recursive dictionary,
+	// the only thing we can do is make sure the writer doesn't blow up
+
+	// Self recursive
+	Dictionary d;
+	d[d] = 1;
+
+	// Writer should it recursion limit while visiting the dictionary
+	ERR_PRINT_OFF;
+	String d_str;
+	VariantWriter::write_to_string(d, d_str);
+	ERR_PRINT_ON;
+
+	// Nested recursive
+	Dictionary d1;
+	Dictionary d2;
+	d1[d2] = 2;
+	d2[d1] = 1;
+
+	// Writer should it recursion limit while visiting the dictionary
+	ERR_PRINT_OFF;
+	String d1_str;
+	VariantWriter::write_to_string(d1, d1_str);
+	ERR_PRINT_ON;
+
+	// Break the recursivity otherwise Dictionary tearndown will leak memory
+	d.clear();
+	d1.clear();
+	d2.clear();
+}
+#endif
+
+TEST_CASE("[Variant] Basic comparison") {
+	CHECK_EQ(Variant(1), Variant(1));
+	CHECK_FALSE(Variant(1) != Variant(1));
+	CHECK_NE(Variant(1), Variant(2));
+	CHECK_EQ(Variant(String("foo")), Variant(String("foo")));
+	CHECK_NE(Variant(String("foo")), Variant(String("bar")));
+	// Check "empty" version of different types are not equivalents
+	CHECK_NE(Variant(0), Variant());
+	CHECK_NE(Variant(String()), Variant());
+	CHECK_NE(Variant(Array()), Variant());
+	CHECK_NE(Variant(Dictionary()), Variant());
+}
+
+TEST_CASE("[Variant] Nested array comparison") {
+	Array a1 = build_array(1, build_array(2, 3));
+	Array a2 = build_array(1, build_array(2, 3));
+	Array a_other = build_array(1, build_array(2, 4));
+	Variant v_a1 = a1;
+	Variant v_a1_ref2 = a1;
+	Variant v_a2 = a2;
+	Variant v_a_other = a_other;
+
+	// test both operator== and operator!=
+	CHECK_EQ(v_a1, v_a1);
+	CHECK_FALSE(v_a1 != v_a1);
+	CHECK_EQ(v_a1, v_a1_ref2);
+	CHECK_FALSE(v_a1 != v_a1_ref2);
+	CHECK_EQ(v_a1, v_a2);
+	CHECK_FALSE(v_a1 != v_a2);
+	CHECK_NE(v_a1, v_a_other);
+	CHECK_FALSE(v_a1 == v_a_other);
+}
+
+TEST_CASE("[Variant] Nested dictionary comparison") {
+	Dictionary d1 = build_dictionary(build_dictionary(1, 2), build_dictionary(3, 4));
+	Dictionary d2 = build_dictionary(build_dictionary(1, 2), build_dictionary(3, 4));
+	Dictionary d_other_key = build_dictionary(build_dictionary(1, 0), build_dictionary(3, 4));
+	Dictionary d_other_val = build_dictionary(build_dictionary(1, 2), build_dictionary(3, 0));
+	Variant v_d1 = d1;
+	Variant v_d1_ref2 = d1;
+	Variant v_d2 = d2;
+	Variant v_d_other_key = d_other_key;
+	Variant v_d_other_val = d_other_val;
+
+	// test both operator== and operator!=
+	CHECK_EQ(v_d1, v_d1);
+	CHECK_FALSE(v_d1 != v_d1);
+	CHECK_EQ(v_d1, v_d1_ref2);
+	CHECK_FALSE(v_d1 != v_d1_ref2);
+	CHECK_EQ(v_d1, v_d2);
+	CHECK_FALSE(v_d1 != v_d2);
+	CHECK_NE(v_d1, v_d_other_key);
+	CHECK_FALSE(v_d1 == v_d_other_key);
+	CHECK_NE(v_d1, v_d_other_val);
+	CHECK_FALSE(v_d1 == v_d_other_val);
+}
+
 } // namespace TestVariant
 
 #endif // TEST_VARIANT_H
diff --git a/tests/test_code_edit.h b/tests/scene/test_code_edit.h
index 62235ed0ae..202ba8dca5 100644
--- a/tests/test_code_edit.h
+++ b/tests/scene/test_code_edit.h
@@ -31,12 +31,7 @@
 #ifndef TEST_CODE_EDIT_H
 #define TEST_CODE_EDIT_H
 
-#include "core/input/input_map.h"
-#include "core/object/message_queue.h"
-#include "core/os/keyboard.h"
-#include "core/string/string_builder.h"
 #include "scene/gui/code_edit.h"
-#include "scene/resources/default_theme/default_theme.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_curve.h b/tests/scene/test_curve.h
index e079905e35..60eafad460 100644
--- a/tests/test_curve.h
+++ b/tests/scene/test_curve.h
@@ -33,7 +33,7 @@
 
 #include "scene/resources/curve.h"
 
-#include "thirdparty/doctest/doctest.h"
+#include "tests/test_macros.h"
 
 namespace TestCurve {
 
diff --git a/tests/test_gradient.h b/tests/scene/test_gradient.h
index 8eaa6b2b64..fc595b02f2 100644
--- a/tests/test_gradient.h
+++ b/tests/scene/test_gradient.h
@@ -31,8 +31,6 @@
 #ifndef TEST_GRADIENT_H
 #define TEST_GRADIENT_H
 
-#include "core/math/color.h"
-#include "core/object/class_db.h"
 #include "scene/resources/gradient.h"
 
 #include "thirdparty/doctest/doctest.h"
diff --git a/tests/test_gui.cpp b/tests/scene/test_gui.cpp
index 0ec8aa78c4..5bd9390cb7 100644
--- a/tests/test_gui.cpp
+++ b/tests/scene/test_gui.cpp
@@ -32,29 +32,18 @@
 
 #include "test_gui.h"
 
-#include "core/io/image_loader.h"
-#include "core/os/os.h"
-#include "core/string/print_string.h"
-#include "scene/2d/sprite_2d.h"
 #include "scene/gui/button.h"
-#include "scene/gui/control.h"
 #include "scene/gui/label.h"
 #include "scene/gui/line_edit.h"
 #include "scene/gui/menu_button.h"
 #include "scene/gui/option_button.h"
 #include "scene/gui/panel.h"
-#include "scene/gui/popup_menu.h"
 #include "scene/gui/progress_bar.h"
 #include "scene/gui/rich_text_label.h"
 #include "scene/gui/scroll_bar.h"
 #include "scene/gui/spin_box.h"
 #include "scene/gui/tab_container.h"
-#include "scene/gui/texture_rect.h"
 #include "scene/gui/tree.h"
-#include "scene/main/scene_tree.h"
-
-#include "scene/3d/camera_3d.h"
-#include "scene/main/window.h"
 
 namespace TestGUI {
 
@@ -267,4 +256,4 @@ MainLoop *test() {
 }
 } // namespace TestGUI
 
-#endif
+#endif // _3D_DISABLED
diff --git a/tests/test_gui.h b/tests/scene/test_gui.h
index e5c40de7e8..84bce620e2 100644
--- a/tests/test_gui.h
+++ b/tests/scene/test_gui.h
@@ -31,7 +31,7 @@
 #ifndef TEST_GUI_H
 #define TEST_GUI_H
 
-#include "core/os/main_loop.h"
+class MainLoop;
 
 namespace TestGUI {
 
diff --git a/tests/test_path_3d.h b/tests/scene/test_path_3d.h
index 9961ae6e97..1fcef3adde 100644
--- a/tests/test_path_3d.h
+++ b/tests/scene/test_path_3d.h
@@ -32,7 +32,6 @@
 #define TEST_PATH_3D_H
 
 #include "scene/3d/path_3d.h"
-#include "scene/resources/curve.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_path_follow_2d.h b/tests/scene/test_path_follow_2d.h
index 388b690060..ddfcc5552a 100644
--- a/tests/test_path_follow_2d.h
+++ b/tests/scene/test_path_follow_2d.h
@@ -32,7 +32,6 @@
 #define TEST_PATH_FOLLOW_2D_H
 
 #include "scene/2d/path_2d.h"
-#include "scene/resources/curve.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_path_follow_3d.h b/tests/scene/test_path_follow_3d.h
index b6b4c88222..6a505dbb39 100644
--- a/tests/test_path_follow_3d.h
+++ b/tests/scene/test_path_follow_3d.h
@@ -32,7 +32,6 @@
 #define TEST_PATH_FOLLOW_3D_H
 
 #include "scene/3d/path_3d.h"
-#include "scene/resources/curve.h"
 
 #include "tests/test_macros.h"
 
diff --git a/tests/test_physics_2d.cpp b/tests/servers/test_physics_2d.cpp
index f6619db8fd..b6360cde8a 100644
--- a/tests/test_physics_2d.cpp
+++ b/tests/servers/test_physics_2d.cpp
@@ -31,11 +31,6 @@
 #include "test_physics_2d.h"
 
 #include "core/os/main_loop.h"
-#include "core/os/os.h"
-#include "core/string/print_string.h"
-#include "core/templates/map.h"
-#include "scene/resources/texture.h"
-#include "servers/display_server.h"
 #include "servers/physics_server_2d.h"
 #include "servers/rendering_server.h"
 
diff --git a/tests/test_physics_2d.h b/tests/servers/test_physics_2d.h
index 966d49200a..2ae1053a03 100644
--- a/tests/test_physics_2d.h
+++ b/tests/servers/test_physics_2d.h
@@ -31,7 +31,7 @@
 #ifndef TEST_PHYSICS_2D_H
 #define TEST_PHYSICS_2D_H
 
-#include "core/os/main_loop.h"
+class MainLoop;
 
 namespace TestPhysics2D {
 
diff --git a/tests/test_physics_3d.cpp b/tests/servers/test_physics_3d.cpp
index d839ae26b7..4e483d628d 100644
--- a/tests/test_physics_3d.cpp
+++ b/tests/servers/test_physics_3d.cpp
@@ -31,12 +31,8 @@
 #include "test_physics_3d.h"
 
 #include "core/math/convex_hull.h"
-#include "core/math/math_funcs.h"
+#include "core/math/geometry_3d.h"
 #include "core/os/main_loop.h"
-#include "core/os/os.h"
-#include "core/string/print_string.h"
-#include "core/templates/map.h"
-#include "servers/display_server.h"
 #include "servers/physics_server_3d.h"
 #include "servers/rendering_server.h"
 
diff --git a/tests/test_physics_3d.h b/tests/servers/test_physics_3d.h
index b6b66f350e..b86327cdb4 100644
--- a/tests/test_physics_3d.h
+++ b/tests/servers/test_physics_3d.h
@@ -31,7 +31,7 @@
 #ifndef TEST_PHYSICS_H
 #define TEST_PHYSICS_H
 
-#include "core/os/main_loop.h"
+class MainLoop;
 
 namespace TestPhysics3D {
 
diff --git a/tests/test_render.cpp b/tests/servers/test_render.cpp
index 21b4da9b3b..183f049238 100644
--- a/tests/test_render.cpp
+++ b/tests/servers/test_render.cpp
@@ -31,12 +31,7 @@
 #include "test_render.h"
 
 #include "core/math/convex_hull.h"
-#include "core/math/math_funcs.h"
-#include "core/os/keyboard.h"
 #include "core/os/main_loop.h"
-#include "core/os/os.h"
-#include "core/string/print_string.h"
-#include "servers/display_server.h"
 #include "servers/rendering_server.h"
 
 #define OBJECT_COUNT 50
diff --git a/tests/test_render.h b/tests/servers/test_render.h
index 35bb383773..1d773cb347 100644
--- a/tests/test_render.h
+++ b/tests/servers/test_render.h
@@ -31,11 +31,11 @@
 #ifndef TEST_RENDER_H
 #define TEST_RENDER_H
 
-#include "core/os/main_loop.h"
+class MainLoop;
 
 namespace TestRender {
 
 MainLoop *test();
 }
 
-#endif
+#endif // TEST_RENDER_H
diff --git a/tests/test_shader_lang.cpp b/tests/servers/test_shader_lang.cpp
index 5598852f29..0591bf6adf 100644
--- a/tests/test_shader_lang.cpp
+++ b/tests/servers/test_shader_lang.cpp
@@ -30,13 +30,8 @@
 
 #include "test_shader_lang.h"
 
-#include "core/io/file_access.h"
 #include "core/os/main_loop.h"
 #include "core/os/os.h"
-
-#include "core/string/print_string.h"
-#include "scene/gui/control.h"
-#include "scene/gui/text_edit.h"
 #include "servers/rendering/shader_language.h"
 
 typedef ShaderLanguage SL;
diff --git a/tests/test_shader_lang.h b/tests/servers/test_shader_lang.h
index 46a2e6af35..de7ec002b6 100644
--- a/tests/test_shader_lang.h
+++ b/tests/servers/test_shader_lang.h
@@ -31,7 +31,7 @@
 #ifndef TEST_SHADER_LANG_H
 #define TEST_SHADER_LANG_H
 
-#include "core/os/main_loop.h"
+class MainLoop;
 
 namespace TestShaderLang {
 
diff --git a/tests/test_text_server.h b/tests/servers/test_text_server.h
index af3df7bc79..4edffe3711 100644
--- a/tests/test_text_server.h
+++ b/tests/servers/test_text_server.h
@@ -265,6 +265,29 @@ TEST_SUITE("[[TextServer]") {
 				font.clear();
 			}
 		}
+
+		SUBCASE("[TextServer] Strip Diacritics") {
+			for (int i = 0; i < TextServerManager::get_singleton()->get_interface_count(); i++) {
+				Ref<TextServer> ts = TextServerManager::get_singleton()->get_interface(i);
+				TEST_FAIL_COND(ts.is_null(), "Invalid TS interface.");
+
+				if (ts->has_feature(TextServer::FEATURE_SHAPING)) {
+					CHECK(ts->strip_diacritics(U"ٱلسَّلَامُ عَلَيْكُمْ") == U"ٱلسلام عليكم");
+				}
+
+				CHECK(ts->strip_diacritics(U"pêches épinards tomates fraises") == U"peches epinards tomates fraises");
+				CHECK(ts->strip_diacritics(U"ΆΈΉΊΌΎΏΪΫϓϔ") == U"ΑΕΗΙΟΥΩΙΥΥΥ");
+				CHECK(ts->strip_diacritics(U"άέήίΐϊΰϋόύώ") == U"αεηιιιυυουω");
+				CHECK(ts->strip_diacritics(U"ЀЁЃ ЇЌЍӢӤЙ ЎӮӰӲ ӐӒӖӚӜӞ ӦӪ Ӭ Ӵ Ӹ") == U"ЕЕГ ІКИИИИ УУУУ ААЕӘЖЗ ОӨ Э Ч Ы");
+				CHECK(ts->strip_diacritics(U"ѐёѓ їќѝӣӥй ўӯӱӳ ӑӓӗӛӝӟ ӧӫ ӭ ӵ ӹ") == U"еег ікииии уууу ааеәжз оө э ч ы");
+				CHECK(ts->strip_diacritics(U"ÀÁÂÃÄÅĀĂĄÇĆĈĊČĎÈÉÊËĒĔĖĘĚĜĞĠĢĤÌÍÎÏĨĪĬĮİĴĶĹĻĽÑŃŅŇŊÒÓÔÕÖØŌŎŐƠŔŖŘŚŜŞŠŢŤÙÚÛÜŨŪŬŮŰŲƯŴÝŶŹŻŽ") == U"AAAAAAAAACCCCCDEEEEEEEEEGGGGHIIIIIIIIIJKLLLNNNNŊOOOOOØOOOORRRSSSSTTUUUUUUUUUUUWYYZZZ");
+				CHECK(ts->strip_diacritics(U"àáâãäåāăąçćĉċčďèéêëēĕėęěĝğġģĥìíîïĩīĭįĵķĺļľñńņňŋòóôõöøōŏőơŕŗřśŝşšţťùúûüũūŭůűųưŵýÿŷźżž") == U"aaaaaaaaacccccdeeeeeeeeegggghiiiiiiiijklllnnnnŋoooooøoooorrrssssttuuuuuuuuuuuwyyyzzz");
+				CHECK(ts->strip_diacritics(U"ǍǏȈǑǪǬȌȎȪȬȮȰǓǕǗǙǛȔȖǞǠǺȀȂȦǢǼǦǴǨǸȆȐȒȘȚȞȨ Ḁ ḂḄḆ Ḉ ḊḌḎḐḒ ḔḖḘḚḜ Ḟ Ḡ ḢḤḦḨḪ ḬḮ ḰḲḴ ḶḸḺḼ ḾṀṂ ṄṆṈṊ ṌṎṐṒ ṔṖ ṘṚṜṞ ṠṢṤṦṨ ṪṬṮṰ ṲṴṶṸṺ") == U"AIIOOOOOOOOOUUUUUUUAAAAAAÆÆGGKNERRSTHE A BBB C DDDDD EEEEE F G HHHHH II KKK LLLL MMM NNNN OOOO PP RRRR SSSSS TTTT UUUUU");
+				CHECK(ts->strip_diacritics(U"ǎǐȉȋǒǫǭȍȏȫȭȯȱǔǖǘǚǜȕȗǟǡǻȁȃȧǣǽǧǵǩǹȇȑȓșțȟȩ ḁ ḃḅḇ ḉ ḋḍḏḑḓ ḟ ḡ ḭḯ ḱḳḵ ḷḹḻḽ ḿṁṃ ṅṇṉṋ ṍṏṑṓ ṗṕ ṙṛṝṟ ṡṣṥṧṩ ṫṭṯṱ ṳṵṷṹṻ") == U"aiiiooooooooouuuuuuuaaaaaaææggknerrsthe a bbb c ddddd f g ii kkk llll mmm nnnn oooo pp rrrr sssss tttt uuuuu");
+				CHECK(ts->strip_diacritics(U"ṼṾ ẀẂẄẆẈ ẊẌ Ẏ ẐẒẔ") == U"VV WWWWW XX Y ZZZ");
+				CHECK(ts->strip_diacritics(U"ṽṿ ẁẃẅẇẉ ẋẍ ẏ ẑẓẕ ẖ ẗẘẙẛ") == U"vv wwwww xx y zzz h twys");
+			}
+		}
 	}
 }
 }; // namespace TestTextServer
diff --git a/tests/test_dictionary.h b/tests/test_dictionary.h
deleted file mode 100644
index b94cf36109..0000000000
--- a/tests/test_dictionary.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*************************************************************************/
-/*  test_dictionary.h                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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.                */
-/*************************************************************************/
-
-#ifndef TEST_DICTIONARY_H
-#define TEST_DICTIONARY_H
-
-#include "core/templates/ordered_hash_map.h"
-#include "core/templates/safe_refcount.h"
-#include "core/variant/dictionary.h"
-#include "core/variant/variant.h"
-#include "tests/test_macros.h"
-
-namespace TestDictionary {
-
-TEST_CASE("[Dictionary] Assignment using bracket notation ([])") {
-	Dictionary map;
-	map["Hello"] = 0;
-	CHECK(int(map["Hello"]) == 0);
-	map["Hello"] = 3;
-	CHECK(int(map["Hello"]) == 3);
-	map["World!"] = 4;
-	CHECK(int(map["World!"]) == 4);
-
-	// Test non-string keys, since keys can be of any Variant type.
-	map[12345] = -5;
-	CHECK(int(map[12345]) == -5);
-	map[false] = 128;
-	CHECK(int(map[false]) == 128);
-	map[Vector2(10, 20)] = 30;
-	CHECK(int(map[Vector2(10, 20)]) == 30);
-	map[0] = 400;
-	CHECK(int(map[0]) == 400);
-	// Check that assigning 0 doesn't overwrite the value for `false`.
-	CHECK(int(map[false]) == 128);
-}
-
-TEST_CASE("[Dictionary] == and != operators") {
-	Dictionary map1;
-	Dictionary map2;
-	CHECK(map1 != map2);
-	map1[1] = 3;
-	map2 = map1;
-	CHECK(map1 == map2);
-}
-
-TEST_CASE("[Dictionary] get_key_lists()") {
-	Dictionary map;
-	List<Variant> keys;
-	List<Variant> *ptr = &keys;
-	map.get_key_list(ptr);
-	CHECK(keys.is_empty());
-	map[1] = 3;
-	map.get_key_list(ptr);
-	CHECK(keys.size() == 1);
-	CHECK(int(keys[0]) == 1);
-	map[2] = 4;
-	map.get_key_list(ptr);
-	CHECK(keys.size() == 3);
-}
-
-TEST_CASE("[Dictionary] get_key_at_index()") {
-	Dictionary map;
-	map[4] = 3;
-	Variant val = map.get_key_at_index(0);
-	CHECK(int(val) == 4);
-	map[3] = 1;
-	val = map.get_key_at_index(0);
-	CHECK(int(val) == 4);
-	val = map.get_key_at_index(1);
-	CHECK(int(val) == 3);
-}
-
-TEST_CASE("[Dictionary] getptr()") {
-	Dictionary map;
-	map[1] = 3;
-	Variant *key = map.getptr(1);
-	CHECK(int(*key) == 3);
-	key = map.getptr(2);
-	CHECK(key == nullptr);
-}
-
-TEST_CASE("[Dictionary] get_valid()") {
-	Dictionary map;
-	map[1] = 3;
-	Variant val = map.get_valid(1);
-	CHECK(int(val) == 3);
-}
-TEST_CASE("[Dictionary] get()") {
-	Dictionary map;
-	map[1] = 3;
-	Variant val = map.get(1, -1);
-	CHECK(int(val) == 3);
-}
-
-TEST_CASE("[Dictionary] size(), empty() and clear()") {
-	Dictionary map;
-	CHECK(map.size() == 0);
-	CHECK(map.is_empty());
-	map[1] = 3;
-	CHECK(map.size() == 1);
-	CHECK(!map.is_empty());
-	map.clear();
-	CHECK(map.size() == 0);
-	CHECK(map.is_empty());
-}
-
-TEST_CASE("[Dictionary] has() and has_all()") {
-	Dictionary map;
-	CHECK(map.has(1) == false);
-	map[1] = 3;
-	CHECK(map.has(1));
-	Array keys;
-	keys.push_back(1);
-	CHECK(map.has_all(keys));
-	keys.push_back(2);
-	CHECK(map.has_all(keys) == false);
-}
-
-TEST_CASE("[Dictionary] keys() and values()") {
-	Dictionary map;
-	Array keys = map.keys();
-	Array values = map.values();
-	CHECK(keys.is_empty());
-	CHECK(values.is_empty());
-	map[1] = 3;
-	keys = map.keys();
-	values = map.values();
-	CHECK(int(keys[0]) == 1);
-	CHECK(int(values[0]) == 3);
-}
-} // namespace TestDictionary
-#endif // TEST_DICTIONARY_H
diff --git a/tests/test_macros.h b/tests/test_macros.h
index 2f0bc6dcfa..0ec6eb9e7c 100644
--- a/tests/test_macros.h
+++ b/tests/test_macros.h
@@ -31,9 +31,8 @@
 #ifndef TEST_MACROS_H
 #define TEST_MACROS_H
 
-#include "core/object/callable_method_pointer.h"
-#include "core/object/class_db.h"
-#include "core/templates/map.h"
+#include "core/input/input_map.h"
+#include "core/object/message_queue.h"
 #include "core/variant/variant.h"
 
 // See documentation for doctest at:
diff --git a/tests/test_main.cpp b/tests/test_main.cpp
index 341fb1af61..a09be08de8 100644
--- a/tests/test_main.cpp
+++ b/tests/test_main.cpp
@@ -30,62 +30,62 @@
 
 #include "test_main.h"
 
-#include "core/templates/list.h"
-
-#include "test_aabb.h"
-#include "test_array.h"
-#include "test_astar.h"
-#include "test_basis.h"
-#include "test_class_db.h"
-#include "test_code_edit.h"
-#include "test_color.h"
-#include "test_command_queue.h"
-#include "test_config_file.h"
-#include "test_crypto.h"
-#include "test_curve.h"
-#include "test_dictionary.h"
-#include "test_expression.h"
-#include "test_file_access.h"
-#include "test_geometry_2d.h"
-#include "test_geometry_3d.h"
-#include "test_gradient.h"
-#include "test_gui.h"
-#include "test_hashing_context.h"
-#include "test_image.h"
-#include "test_json.h"
-#include "test_list.h"
-#include "test_local_vector.h"
-#include "test_lru.h"
-#include "test_marshalls.h"
-#include "test_math.h"
-#include "test_method_bind.h"
-#include "test_node_path.h"
-#include "test_oa_hash_map.h"
-#include "test_object.h"
-#include "test_ordered_hash_map.h"
-#include "test_paged_array.h"
-#include "test_path_3d.h"
-#include "test_pck_packer.h"
-#include "test_physics_2d.h"
-#include "test_physics_3d.h"
-#include "test_random_number_generator.h"
-#include "test_rect2.h"
-#include "test_render.h"
-#include "test_resource.h"
-#include "test_shader_lang.h"
-#include "test_string.h"
-#include "test_text_server.h"
-#include "test_time.h"
-#include "test_translation.h"
-#include "test_validate_testing.h"
-#include "test_variant.h"
-#include "test_vector.h"
-#include "test_xml_parser.h"
+#include "tests/core/io/test_config_file.h"
+#include "tests/core/io/test_file_access.h"
+#include "tests/core/io/test_image.h"
+#include "tests/core/io/test_json.h"
+#include "tests/core/io/test_marshalls.h"
+#include "tests/core/io/test_pck_packer.h"
+#include "tests/core/io/test_resource.h"
+#include "tests/core/io/test_xml_parser.h"
+#include "tests/core/math/test_aabb.h"
+#include "tests/core/math/test_astar.h"
+#include "tests/core/math/test_basis.h"
+#include "tests/core/math/test_color.h"
+#include "tests/core/math/test_expression.h"
+#include "tests/core/math/test_geometry_2d.h"
+#include "tests/core/math/test_geometry_3d.h"
+#include "tests/core/math/test_math.h"
+#include "tests/core/math/test_random_number_generator.h"
+#include "tests/core/math/test_rect2.h"
+#include "tests/core/object/test_class_db.h"
+#include "tests/core/object/test_method_bind.h"
+#include "tests/core/object/test_object.h"
+#include "tests/core/string/test_node_path.h"
+#include "tests/core/string/test_string.h"
+#include "tests/core/string/test_translation.h"
+#include "tests/core/templates/test_command_queue.h"
+#include "tests/core/templates/test_list.h"
+#include "tests/core/templates/test_local_vector.h"
+#include "tests/core/templates/test_lru.h"
+#include "tests/core/templates/test_oa_hash_map.h"
+#include "tests/core/templates/test_ordered_hash_map.h"
+#include "tests/core/templates/test_paged_array.h"
+#include "tests/core/templates/test_vector.h"
+#include "tests/core/test_crypto.h"
+#include "tests/core/test_hashing_context.h"
+#include "tests/core/test_time.h"
+#include "tests/core/variant/test_array.h"
+#include "tests/core/variant/test_dictionary.h"
+#include "tests/core/variant/test_variant.h"
+#include "tests/scene/test_code_edit.h"
+#include "tests/scene/test_curve.h"
+#include "tests/scene/test_gradient.h"
+#include "tests/scene/test_gui.h"
+#include "tests/scene/test_path_3d.h"
+#include "tests/servers/test_physics_2d.h"
+#include "tests/servers/test_physics_3d.h"
+#include "tests/servers/test_render.h"
+#include "tests/servers/test_shader_lang.h"
+#include "tests/servers/test_text_server.h"
+#include "tests/test_validate_testing.h"
 
 #include "modules/modules_tests.gen.h"
 
 #include "tests/test_macros.h"
 
+#include "scene/resources/default_theme/default_theme.h"
+
 int test_main(int argc, char *argv[]) {
 	bool run_tests = true;
 
diff --git a/tests/test_tools.h b/tests/test_tools.h
index ec18610f04..e1192458d0 100644
--- a/tests/test_tools.h
+++ b/tests/test_tools.h
@@ -31,8 +31,6 @@
 #ifndef TEST_TOOLS_H
 #define TEST_TOOLS_H
 
-#include "core/error/error_macros.h"
-
 struct ErrorDetector {
 	ErrorDetector() {
 		eh.errfunc = _detect_error;
diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp
index 1666a257a9..890dea3ee1 100644
--- a/tests/test_utils.cpp
+++ b/tests/test_utils.cpp
@@ -28,7 +28,7 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "test_utils.h"
+#include "tests/test_utils.h"
 
 #include "core/os/os.h"
 
diff --git a/tests/test_utils.h b/tests/test_utils.h
index f05ab0bdb1..ccebe2e449 100644
--- a/tests/test_utils.h
+++ b/tests/test_utils.h
@@ -31,7 +31,7 @@
 #ifndef TEST_UTILS_H
 #define TEST_UTILS_H
 
-#include "core/string/ustring.h"
+class String;
 
 namespace TestUtils {