summaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/core/io/test_ip.h51
-rw-r--r--tests/core/io/test_marshalls.h78
-rw-r--r--tests/core/math/test_geometry_2d.h86
-rw-r--r--tests/core/math/test_geometry_3d.h6
-rw-r--r--tests/core/math/test_transform_3d.h29
-rw-r--r--tests/core/math/test_vector2.h4
-rw-r--r--tests/core/templates/test_command_queue.h44
-rw-r--r--tests/core/templates/test_oa_hash_map.h225
-rw-r--r--tests/core/threads/test_worker_thread_pool.h67
-rw-r--r--tests/core/variant/test_array.h52
-rw-r--r--tests/scene/test_camera_2d.h318
-rw-r--r--tests/scene/test_code_edit.h1
-rw-r--r--tests/scene/test_navigation_region_2d.h2
-rw-r--r--tests/scene/test_navigation_region_3d.h11
-rw-r--r--tests/servers/test_navigation_server_3d.h3
-rw-r--r--tests/test_main.cpp5
16 files changed, 918 insertions, 64 deletions
diff --git a/tests/core/io/test_ip.h b/tests/core/io/test_ip.h
new file mode 100644
index 0000000000..7b5583faa0
--- /dev/null
+++ b/tests/core/io/test_ip.h
@@ -0,0 +1,51 @@
+/**************************************************************************/
+/* test_ip.h */
+/**************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/**************************************************************************/
+
+#ifndef TEST_IP_H
+#define TEST_IP_H
+
+#include "core/io/ip.h"
+
+#include "tests/test_macros.h"
+
+namespace TestIP {
+
+TEST_CASE("[IP] resolve_hostname") {
+ for (int x = 0; x < 1000; x++) {
+ IPAddress IPV4 = IP::get_singleton()->resolve_hostname("localhost", IP::TYPE_IPV4);
+ CHECK("127.0.0.1" == String(IPV4));
+ IPAddress IPV6 = IP::get_singleton()->resolve_hostname("localhost", IP::TYPE_IPV6);
+ CHECK("0:0:0:0:0:0:0:1" == String(IPV6));
+ }
+}
+
+} // namespace TestIP
+
+#endif // TEST_IP_H
diff --git a/tests/core/io/test_marshalls.h b/tests/core/io/test_marshalls.h
index 3c0ba611c6..de8d6e1406 100644
--- a/tests/core/io/test_marshalls.h
+++ b/tests/core/io/test_marshalls.h
@@ -160,7 +160,7 @@ TEST_CASE("[Marshalls] NIL Variant encoding") {
uint8_t buffer[4];
CHECK(encode_variant(variant, buffer, r_len) == OK);
- CHECK_MESSAGE(r_len == 4, "Length == 4 bytes for Variant::Type");
+ CHECK_MESSAGE(r_len == 4, "Length == 4 bytes for header");
CHECK_MESSAGE(buffer[0] == 0x00, "Variant::NIL");
CHECK(buffer[1] == 0x00);
CHECK(buffer[2] == 0x00);
@@ -174,7 +174,7 @@ TEST_CASE("[Marshalls] INT 32 bit Variant encoding") {
uint8_t buffer[8];
CHECK(encode_variant(variant, buffer, r_len) == OK);
- CHECK_MESSAGE(r_len == 8, "Length == 4 bytes for Variant::Type + 4 bytes for int32_t");
+ CHECK_MESSAGE(r_len == 8, "Length == 4 bytes for header + 4 bytes for int32_t");
CHECK_MESSAGE(buffer[0] == 0x02, "Variant::INT");
CHECK(buffer[1] == 0x00);
CHECK(buffer[2] == 0x00);
@@ -192,10 +192,10 @@ TEST_CASE("[Marshalls] INT 64 bit Variant encoding") {
uint8_t buffer[12];
CHECK(encode_variant(variant, buffer, r_len) == OK);
- CHECK_MESSAGE(r_len == 12, "Length == 4 bytes for Variant::Type + 8 bytes for int64_t");
+ CHECK_MESSAGE(r_len == 12, "Length == 4 bytes for header + 8 bytes for int64_t");
CHECK_MESSAGE(buffer[0] == 0x02, "Variant::INT");
CHECK(buffer[1] == 0x00);
- CHECK_MESSAGE(buffer[2] == 0x01, "ENCODE_FLAG_64");
+ CHECK_MESSAGE(buffer[2] == 0x01, "HEADER_DATA_FLAG_64");
CHECK(buffer[3] == 0x00);
// Check value
CHECK(buffer[4] == 0xef);
@@ -214,7 +214,7 @@ TEST_CASE("[Marshalls] FLOAT single precision Variant encoding") {
uint8_t buffer[8];
CHECK(encode_variant(variant, buffer, r_len) == OK);
- CHECK_MESSAGE(r_len == 8, "Length == 4 bytes for Variant::Type + 4 bytes for float");
+ CHECK_MESSAGE(r_len == 8, "Length == 4 bytes for header + 4 bytes for float");
CHECK_MESSAGE(buffer[0] == 0x03, "Variant::FLOAT");
CHECK(buffer[1] == 0x00);
CHECK(buffer[2] == 0x00);
@@ -232,10 +232,10 @@ TEST_CASE("[Marshalls] FLOAT double precision Variant encoding") {
uint8_t buffer[12];
CHECK(encode_variant(variant, buffer, r_len) == OK);
- CHECK_MESSAGE(r_len == 12, "Length == 4 bytes for Variant::Type + 8 bytes for double");
+ CHECK_MESSAGE(r_len == 12, "Length == 4 bytes for header + 8 bytes for double");
CHECK_MESSAGE(buffer[0] == 0x03, "Variant::FLOAT");
CHECK(buffer[1] == 0x00);
- CHECK_MESSAGE(buffer[2] == 0x01, "ENCODE_FLAG_64");
+ CHECK_MESSAGE(buffer[2] == 0x01, "HEADER_DATA_FLAG_64");
CHECK(buffer[3] == 0x00);
// Check value
CHECK(buffer[4] == 0x55);
@@ -292,7 +292,7 @@ TEST_CASE("[Marshalls] INT 64 bit Variant decoding") {
Variant variant;
int r_len;
uint8_t buffer[] = {
- 0x02, 0x00, 0x01, 0x00, // Variant::INT & ENCODE_FLAG_64
+ 0x02, 0x00, 0x01, 0x00, // Variant::INT, HEADER_DATA_FLAG_64
0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0xf1 // value
};
@@ -318,7 +318,7 @@ TEST_CASE("[Marshalls] FLOAT double precision Variant decoding") {
Variant variant;
int r_len;
uint8_t buffer[] = {
- 0x03, 0x00, 0x01, 0x00, // Variant::FLOAT & ENCODE_FLAG_64
+ 0x03, 0x00, 0x01, 0x00, // Variant::FLOAT, HEADER_DATA_FLAG_64
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xd5, 0x3f // value
};
@@ -326,6 +326,66 @@ TEST_CASE("[Marshalls] FLOAT double precision Variant decoding") {
CHECK(r_len == 12);
CHECK(variant == Variant(0.33333333333333333));
}
+
+TEST_CASE("[Marshalls] Typed array encoding") {
+ int r_len;
+ Array array;
+ array.set_typed(Variant::INT, StringName(), Ref<Script>());
+ array.push_back(Variant(uint64_t(0x0f123456789abcdef)));
+ uint8_t buffer[24];
+
+ CHECK(encode_variant(array, buffer, r_len) == OK);
+ CHECK_MESSAGE(r_len == 24, "Length == 4 bytes for header + 4 bytes for array type + 4 bytes for array size + 12 bytes for element");
+ CHECK_MESSAGE(buffer[0] == 0x1c, "Variant::ARRAY");
+ CHECK(buffer[1] == 0x00);
+ CHECK_MESSAGE(buffer[2] == 0x01, "HEADER_DATA_FIELD_TYPED_ARRAY_BUILTIN");
+ CHECK(buffer[3] == 0x00);
+ // Check array type.
+ CHECK_MESSAGE(buffer[4] == 0x02, "Variant::INT");
+ CHECK(buffer[5] == 0x00);
+ CHECK(buffer[6] == 0x00);
+ CHECK(buffer[7] == 0x00);
+ // Check array size.
+ CHECK(buffer[8] == 0x01);
+ CHECK(buffer[9] == 0x00);
+ CHECK(buffer[10] == 0x00);
+ CHECK(buffer[11] == 0x00);
+ // Check element type.
+ CHECK_MESSAGE(buffer[12] == 0x02, "Variant::INT");
+ CHECK(buffer[13] == 0x00);
+ CHECK_MESSAGE(buffer[14] == 0x01, "HEADER_DATA_FLAG_64");
+ CHECK(buffer[15] == 0x00);
+ // Check element value.
+ CHECK(buffer[16] == 0xef);
+ CHECK(buffer[17] == 0xcd);
+ CHECK(buffer[18] == 0xab);
+ CHECK(buffer[19] == 0x89);
+ CHECK(buffer[20] == 0x67);
+ CHECK(buffer[21] == 0x45);
+ CHECK(buffer[22] == 0x23);
+ CHECK(buffer[23] == 0xf1);
+}
+
+TEST_CASE("[Marshalls] Typed array decoding") {
+ Variant variant;
+ int r_len;
+ uint8_t buffer[] = {
+ 0x1c, 0x00, 0x01, 0x00, // Variant::ARRAY, HEADER_DATA_FIELD_TYPED_ARRAY_BUILTIN
+ 0x02, 0x00, 0x00, 0x00, // Array type (Variant::INT).
+ 0x01, 0x00, 0x00, 0x00, // Array size.
+ 0x02, 0x00, 0x01, 0x00, // Element type (Variant::INT, HEADER_DATA_FLAG_64).
+ 0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0xf1, // Element value.
+ };
+
+ CHECK(decode_variant(variant, buffer, 24, &r_len) == OK);
+ CHECK(r_len == 24);
+ CHECK(variant.get_type() == Variant::ARRAY);
+ Array array = variant;
+ CHECK(array.get_typed_builtin() == Variant::INT);
+ CHECK(array.size() == 1);
+ CHECK(array[0] == Variant(uint64_t(0x0f123456789abcdef)));
+}
+
} // namespace TestMarshalls
#endif // TEST_MARSHALLS_H
diff --git a/tests/core/math/test_geometry_2d.h b/tests/core/math/test_geometry_2d.h
index c3ff4f3ec9..50b2575700 100644
--- a/tests/core/math/test_geometry_2d.h
+++ b/tests/core/math/test_geometry_2d.h
@@ -282,41 +282,67 @@ TEST_CASE("[Geometry2D] Closest point to uncapped segment") {
TEST_CASE("[Geometry2D] Closest points between segments") {
Vector2 c1, c2;
- Geometry2D::get_closest_points_between_segments(Vector2(2, 2), Vector2(3, 3), Vector2(4, 4), Vector2(4, 5), c1, c2);
- CHECK(c1.is_equal_approx(Vector2(3, 3)));
- CHECK(c2.is_equal_approx(Vector2(4, 4)));
+ // Basis Path Testing suite
+ SUBCASE("[Geometry2D] Both segments degenerate to a point") {
+ Geometry2D::get_closest_points_between_segments(Vector2(0, 0), Vector2(0, 0), Vector2(0, 0), Vector2(0, 0), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(0, 0)));
+ CHECK(c2.is_equal_approx(Vector2(0, 0)));
+ }
- Geometry2D::get_closest_points_between_segments(Vector2(0, 1), Vector2(-2, -1), Vector2(0, 0), Vector2(2, -2), c1, c2);
- CHECK(c1.is_equal_approx(Vector2(-0.5, 0.5)));
- CHECK(c2.is_equal_approx(Vector2(0, 0)));
+ SUBCASE("[Geometry2D] Closest point on second segment trajectory is above [0,1]") {
+ Geometry2D::get_closest_points_between_segments(Vector2(50, -25), Vector2(50, -10), Vector2(-50, 10), Vector2(-40, 10), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(50, -10)));
+ CHECK(c2.is_equal_approx(Vector2(-40, 10)));
+ }
- Geometry2D::get_closest_points_between_segments(Vector2(-1, 1), Vector2(1, -1), Vector2(1, 1), Vector2(-1, -1), c1, c2);
- CHECK(c1.is_equal_approx(Vector2(0, 0)));
- CHECK(c2.is_equal_approx(Vector2(0, 0)));
+ SUBCASE("[Geometry2D] Parallel segments") {
+ Geometry2D::get_closest_points_between_segments(Vector2(2, 1), Vector2(4, 3), Vector2(2, 3), Vector2(4, 5), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(3, 2)));
+ CHECK(c2.is_equal_approx(Vector2(2, 3)));
+ }
- Geometry2D::get_closest_points_between_segments(Vector2(-3, 4), Vector2(-3, 4), Vector2(-4, 3), Vector2(-2, 3), c1, c2);
- CHECK_MESSAGE(
- c1.is_equal_approx(Vector2(-3, 4)),
- "1st line segment is only a point, this point should be the closest point to the 2nd line segment.");
- CHECK_MESSAGE(
- c2.is_equal_approx(Vector2(-3, 3)),
- "1st line segment is only a point, this should not matter when determining the closest point on the 2nd line segment.");
+ SUBCASE("[Geometry2D] Closest point on second segment trajectory is within [0,1]") {
+ Geometry2D::get_closest_points_between_segments(Vector2(2, 4), Vector2(2, 3), Vector2(1, 1), Vector2(4, 4), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(2, 3)));
+ CHECK(c2.is_equal_approx(Vector2(2.5, 2.5)));
+ }
- Geometry2D::get_closest_points_between_segments(Vector2(-4, 3), Vector2(-2, 3), Vector2(-3, 4), Vector2(-3, 4), c1, c2);
- CHECK_MESSAGE(
- c1.is_equal_approx(Vector2(-3, 3)),
- "2nd line segment is only a point, this should not matter when determining the closest point on the 1st line segment.");
- CHECK_MESSAGE(
- c2.is_equal_approx(Vector2(-3, 4)),
- "2nd line segment is only a point, this point should be the closest point to the 1st line segment.");
+ SUBCASE("[Geometry2D] Closest point on second segment trajectory is below [0,1]") {
+ Geometry2D::get_closest_points_between_segments(Vector2(-20, -20), Vector2(-10, -40), Vector2(10, 25), Vector2(25, 40), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(-20, -20)));
+ CHECK(c2.is_equal_approx(Vector2(10, 25)));
+ }
- Geometry2D::get_closest_points_between_segments(Vector2(5, -4), Vector2(5, -4), Vector2(-2, 1), Vector2(-2, 1), c1, c2);
- CHECK_MESSAGE(
- c1.is_equal_approx(Vector2(5, -4)),
- "Both line segments are only a point. On the 1st line segment, that point should be the closest point to the 2nd line segment.");
- CHECK_MESSAGE(
- c2.is_equal_approx(Vector2(-2, 1)),
- "Both line segments are only a point. On the 2nd line segment, that point should be the closest point to the 1st line segment.");
+ SUBCASE("[Geometry2D] Second segment degenerates to a point") {
+ Geometry2D::get_closest_points_between_segments(Vector2(1, 2), Vector2(2, 1), Vector2(3, 3), Vector2(3, 3), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(1.5, 1.5)));
+ CHECK(c2.is_equal_approx(Vector2(3, 3)));
+ }
+
+ SUBCASE("[Geometry2D] First segment degenerates to a point") {
+ Geometry2D::get_closest_points_between_segments(Vector2(1, 1), Vector2(1, 1), Vector2(2, 2), Vector2(4, 4), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(1, 1)));
+ CHECK(c2.is_equal_approx(Vector2(2, 2)));
+ }
+ // End Basis Path Testing suite
+
+ SUBCASE("[Geometry2D] Segments are equal vectors") {
+ Geometry2D::get_closest_points_between_segments(Vector2(2, 2), Vector2(3, 3), Vector2(4, 4), Vector2(4, 5), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(3, 3)));
+ CHECK(c2.is_equal_approx(Vector2(4, 4)));
+ }
+
+ SUBCASE("[Geometry2D] Standard case") {
+ Geometry2D::get_closest_points_between_segments(Vector2(0, 1), Vector2(-2, -1), Vector2(0, 0), Vector2(2, -2), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(-0.5, 0.5)));
+ CHECK(c2.is_equal_approx(Vector2(0, 0)));
+ }
+
+ SUBCASE("[Geometry2D] Segments intersect") {
+ Geometry2D::get_closest_points_between_segments(Vector2(-1, 1), Vector2(1, -1), Vector2(1, 1), Vector2(-1, -1), c1, c2);
+ CHECK(c1.is_equal_approx(Vector2(0, 0)));
+ CHECK(c2.is_equal_approx(Vector2(0, 0)));
+ }
}
TEST_CASE("[Geometry2D] Make atlas") {
diff --git a/tests/core/math/test_geometry_3d.h b/tests/core/math/test_geometry_3d.h
index 3d83653f11..aaa02cb6a8 100644
--- a/tests/core/math/test_geometry_3d.h
+++ b/tests/core/math/test_geometry_3d.h
@@ -136,9 +136,9 @@ TEST_CASE("[Geometry3D] Get Closest Point To Segment") {
}
TEST_CASE("[Geometry3D] Plane and Box Overlap") {
- CHECK(Geometry3D::planeBoxOverlap(Vector3(3, 4, 2), 5, Vector3(5, 5, 5)) == true);
- CHECK(Geometry3D::planeBoxOverlap(Vector3(0, 1, 0), -10, Vector3(5, 5, 5)) == false);
- CHECK(Geometry3D::planeBoxOverlap(Vector3(1, 0, 0), -6, Vector3(5, 5, 5)) == false);
+ CHECK(Geometry3D::planeBoxOverlap(Vector3(3, 4, 2), 5.0f, Vector3(5, 5, 5)) == true);
+ CHECK(Geometry3D::planeBoxOverlap(Vector3(0, 1, 0), -10.0f, Vector3(5, 5, 5)) == false);
+ CHECK(Geometry3D::planeBoxOverlap(Vector3(1, 0, 0), -6.0f, Vector3(5, 5, 5)) == false);
}
TEST_CASE("[Geometry3D] Is Point in Projected Triangle") {
diff --git a/tests/core/math/test_transform_3d.h b/tests/core/math/test_transform_3d.h
index 551b20fe74..fba0fcb280 100644
--- a/tests/core/math/test_transform_3d.h
+++ b/tests/core/math/test_transform_3d.h
@@ -107,6 +107,35 @@ TEST_CASE("[Transform3D] Finite number checks") {
"Transform3D with two components infinite should not be finite.");
}
+TEST_CASE("[Transform3D] Rotate around global origin") {
+ // Start with the default orientation, but not centered on the origin.
+ // Rotating should rotate both our basis and the origin.
+ Transform3D transform = Transform3D();
+ transform.origin = Vector3(0, 0, 1);
+
+ Transform3D expected = Transform3D();
+ expected.origin = Vector3(0, 0, -1);
+ expected.basis[0] = Vector3(-1, 0, 0);
+ expected.basis[2] = Vector3(0, 0, -1);
+
+ const Transform3D rotated_transform = transform.rotated(Vector3(0, 1, 0), Math_PI);
+ CHECK_MESSAGE(rotated_transform.is_equal_approx(expected), "The rotated transform should have a new orientation and basis.");
+}
+
+TEST_CASE("[Transform3D] Rotate in-place (local rotation)") {
+ // Start with the default orientation.
+ // Local rotation should not change the origin, only the basis.
+ Transform3D transform = Transform3D();
+ transform.origin = Vector3(1, 2, 3);
+
+ Transform3D expected = Transform3D();
+ expected.origin = Vector3(1, 2, 3);
+ expected.basis[0] = Vector3(-1, 0, 0);
+ expected.basis[2] = Vector3(0, 0, -1);
+
+ const Transform3D rotated_transform = Transform3D(transform.rotated_local(Vector3(0, 1, 0), Math_PI));
+ CHECK_MESSAGE(rotated_transform.is_equal_approx(expected), "The rotated transform should have a new orientation but still be based on the same origin.");
+}
} // namespace TestTransform3D
#endif // TEST_TRANSFORM_3D_H
diff --git a/tests/core/math/test_vector2.h b/tests/core/math/test_vector2.h
index f23fffe5eb..fc3fd6a87d 100644
--- a/tests/core/math/test_vector2.h
+++ b/tests/core/math/test_vector2.h
@@ -354,6 +354,7 @@ TEST_CASE("[Vector2] Plane methods") {
const Vector2 vector_y = Vector2(0, 1);
const Vector2 vector_normal = Vector2(0.95879811270838721622267, 0.2840883296913739899919);
const Vector2 vector_non_normal = Vector2(5.4, 1.6);
+ const real_t p_d = 99.1;
CHECK_MESSAGE(
vector.bounce(vector_y) == Vector2(1.2, -3.4),
"Vector2 bounce on a plane with normal of the Y axis should.");
@@ -373,6 +374,9 @@ TEST_CASE("[Vector2] Plane methods") {
vector.project(vector_normal).is_equal_approx(Vector2(2.0292559899117276166, 0.60126103404791929382)),
"Vector2 projected on a normal should return expected value.");
CHECK_MESSAGE(
+ vector_normal.plane_project(p_d, vector).is_equal_approx(Vector2(94.187635516479631, 30.951892004882851)),
+ "Vector2 plane_project should return expected value.");
+ CHECK_MESSAGE(
vector.slide(vector_y) == Vector2(1.2, 0),
"Vector2 slide on a plane with normal of the Y axis should set the Y to zero.");
CHECK_MESSAGE(
diff --git a/tests/core/templates/test_command_queue.h b/tests/core/templates/test_command_queue.h
index e94c108694..d2957b5c40 100644
--- a/tests/core/templates/test_command_queue.h
+++ b/tests/core/templates/test_command_queue.h
@@ -33,6 +33,7 @@
#include "core/config/project_settings.h"
#include "core/math/random_number_generator.h"
+#include "core/object/worker_thread_pool.h"
#include "core/os/os.h"
#include "core/os/thread.h"
#include "core/templates/command_queue_mt.h"
@@ -100,7 +101,7 @@ public:
ThreadWork reader_threadwork;
ThreadWork writer_threadwork;
- CommandQueueMT command_queue = CommandQueueMT(true);
+ CommandQueueMT command_queue;
enum TestMsgType {
TEST_MSG_FUNC1_TRANSFORM,
@@ -119,6 +120,7 @@ public:
bool exit_threads = false;
Thread reader_thread;
+ WorkerThreadPool::TaskID reader_task_id = WorkerThreadPool::INVALID_TASK_ID;
Thread writer_thread;
int func1_count = 0;
@@ -148,11 +150,16 @@ public:
void reader_thread_loop() {
reader_threadwork.thread_wait_for_work();
while (!exit_threads) {
- if (message_count_to_read < 0) {
+ if (reader_task_id == WorkerThreadPool::INVALID_TASK_ID) {
command_queue.flush_all();
- }
- for (int i = 0; i < message_count_to_read; i++) {
- command_queue.wait_and_flush();
+ } else {
+ if (message_count_to_read < 0) {
+ command_queue.flush_all();
+ }
+ for (int i = 0; i < message_count_to_read; i++) {
+ WorkerThreadPool::get_singleton()->yield();
+ command_queue.wait_and_flush();
+ }
}
message_count_to_read = 0;
@@ -216,8 +223,13 @@ public:
sts->writer_thread_loop();
}
- void init_threads() {
- reader_thread.start(&SharedThreadState::static_reader_thread_loop, this);
+ void init_threads(bool p_use_thread_pool_sync = false) {
+ if (p_use_thread_pool_sync) {
+ reader_task_id = WorkerThreadPool::get_singleton()->add_native_task(&SharedThreadState::static_reader_thread_loop, this, true);
+ command_queue.set_pump_task_id(reader_task_id);
+ } else {
+ reader_thread.start(&SharedThreadState::static_reader_thread_loop, this);
+ }
writer_thread.start(&SharedThreadState::static_writer_thread_loop, this);
}
void destroy_threads() {
@@ -225,16 +237,20 @@ public:
reader_threadwork.main_start_work();
writer_threadwork.main_start_work();
- reader_thread.wait_to_finish();
+ if (reader_task_id != WorkerThreadPool::INVALID_TASK_ID) {
+ WorkerThreadPool::get_singleton()->wait_for_task_completion(reader_task_id);
+ } else {
+ reader_thread.wait_to_finish();
+ }
writer_thread.wait_to_finish();
}
};
-TEST_CASE("[CommandQueue] Test Queue Basics") {
+static void test_command_queue_basic(bool p_use_thread_pool_sync) {
const char *COMMAND_QUEUE_SETTING = "memory/limits/command_queue/multithreading_queue_size_kb";
ProjectSettings::get_singleton()->set_setting(COMMAND_QUEUE_SETTING, 1);
SharedThreadState sts;
- sts.init_threads();
+ sts.init_threads(p_use_thread_pool_sync);
sts.add_msg_to_write(SharedThreadState::TEST_MSG_FUNC1_TRANSFORM);
sts.writer_threadwork.main_start_work();
@@ -272,6 +288,14 @@ TEST_CASE("[CommandQueue] Test Queue Basics") {
ProjectSettings::get_singleton()->property_get_revert(COMMAND_QUEUE_SETTING));
}
+TEST_CASE("[CommandQueue] Test Queue Basics") {
+ test_command_queue_basic(false);
+}
+
+TEST_CASE("[CommandQueue] Test Queue Basics with WorkerThreadPool sync.") {
+ test_command_queue_basic(true);
+}
+
TEST_CASE("[CommandQueue] Test Queue Wrapping to same spot.") {
const char *COMMAND_QUEUE_SETTING = "memory/limits/command_queue/multithreading_queue_size_kb";
ProjectSettings::get_singleton()->set_setting(COMMAND_QUEUE_SETTING, 1);
diff --git a/tests/core/templates/test_oa_hash_map.h b/tests/core/templates/test_oa_hash_map.h
new file mode 100644
index 0000000000..9359efa964
--- /dev/null
+++ b/tests/core/templates/test_oa_hash_map.h
@@ -0,0 +1,225 @@
+/**************************************************************************/
+/* test_oa_hash_map.h */
+/**************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/**************************************************************************/
+
+#ifndef TEST_OA_HASH_MAP_H
+#define TEST_OA_HASH_MAP_H
+
+#include "core/templates/oa_hash_map.h"
+#include "scene/resources/texture.h"
+
+#include "tests/test_macros.h"
+
+namespace TestOAHashMap {
+
+TEST_CASE("[OAHashMap] Insert element") {
+ OAHashMap<int, int> map;
+ map.insert(42, 84);
+ int data = 0;
+ bool lookup_res = map.lookup(42, data);
+ int value = *map.lookup_ptr(42);
+ CHECK(lookup_res);
+ CHECK(value == 84);
+ CHECK(data == 84);
+}
+
+TEST_CASE("[OAHashMap] Set element") {
+ OAHashMap<int, int> map;
+ map.set(42, 84);
+ int data = 0;
+ bool lookup_res = map.lookup(42, data);
+ int value = *map.lookup_ptr(42);
+ CHECK(lookup_res);
+ CHECK(value == 84);
+ CHECK(data == 84);
+}
+
+TEST_CASE("[OAHashMap] Overwrite element") {
+ OAHashMap<int, int> map;
+ map.set(42, 84);
+ map.set(42, 1234);
+ int result = *map.lookup_ptr(42);
+ CHECK(result == 1234);
+}
+
+TEST_CASE("[OAHashMap] Remove element") {
+ OAHashMap<int, int> map;
+ map.insert(42, 84);
+ map.remove(42);
+ CHECK(!map.has(42));
+}
+
+TEST_CASE("[OAHashMap] Get Num_Elements") {
+ OAHashMap<int, int> map;
+ map.set(42, 84);
+ map.set(123, 84);
+ map.set(123, 84);
+ map.set(0, 84);
+ map.set(123485, 84);
+
+ CHECK(map.get_num_elements() == 4);
+}
+
+TEST_CASE("[OAHashMap] Iteration") {
+ OAHashMap<int, int> map;
+ map.insert(42, 84);
+ map.insert(123, 12385);
+ map.insert(0, 12934);
+ map.insert(123485, 1238888);
+ map.set(123, 111111);
+
+ Vector<Pair<int, int>> expected;
+ expected.push_back(Pair<int, int>(42, 84));
+ expected.push_back(Pair<int, int>(123, 111111));
+ expected.push_back(Pair<int, int>(0, 12934));
+ expected.push_back(Pair<int, int>(123485, 1238888));
+
+ for (OAHashMap<int, int>::Iterator it = map.iter(); it.valid; it = map.next_iter(it)) {
+ int64_t result = expected.find(Pair<int, int>(*it.key, *it.value));
+ CHECK(result >= 0);
+ }
+}
+
+TEST_CASE("[OAHashMap] Insert, iterate, remove many strings") {
+ uint64_t pre_mem = Memory::get_mem_usage();
+ {
+ const int elem_max = 40;
+ OAHashMap<String, int> map;
+ for (int i = 0; i < elem_max; i++) {
+ map.insert(itos(i), i);
+ }
+
+ Vector<String> elems_still_valid;
+
+ for (int i = 0; i < elem_max; i++) {
+ if ((i % 5) == 0) {
+ map.remove(itos(i));
+ } else {
+ elems_still_valid.push_back(itos(i));
+ }
+ }
+
+ CHECK(elems_still_valid.size() == map.get_num_elements());
+
+ for (int i = 0; i < elems_still_valid.size(); i++) {
+ CHECK(map.has(elems_still_valid[i]));
+ }
+ }
+
+ CHECK(Memory::get_mem_usage() == pre_mem);
+}
+
+TEST_CASE("[OAHashMap] Clear") {
+ OAHashMap<int, int> map;
+ map.insert(42, 84);
+ map.insert(0, 1234);
+ map.clear();
+ CHECK(!map.has(42));
+ CHECK(!map.has(0));
+ CHECK(map.is_empty());
+}
+
+TEST_CASE("[OAHashMap] Copy constructor") {
+ uint64_t pre_mem = Memory::get_mem_usage();
+ {
+ OAHashMap<int, int> map0;
+ const uint32_t count = 5;
+ for (uint32_t i = 0; i < count; i++) {
+ map0.insert(i, i);
+ }
+ OAHashMap<int, int> map1(map0);
+ CHECK(map0.get_num_elements() == map1.get_num_elements());
+ CHECK(map0.get_capacity() == map1.get_capacity());
+ CHECK(*map0.lookup_ptr(0) == *map1.lookup_ptr(0));
+ }
+ CHECK(Memory::get_mem_usage() == pre_mem);
+}
+
+TEST_CASE("[OAHashMap] Operator =") {
+ uint64_t pre_mem = Memory::get_mem_usage();
+ {
+ OAHashMap<int, int> map0;
+ OAHashMap<int, int> map1;
+ const uint32_t count = 5;
+ map1.insert(1234, 1234);
+ for (uint32_t i = 0; i < count; i++) {
+ map0.insert(i, i);
+ }
+ map1 = map0;
+ CHECK(map0.get_num_elements() == map1.get_num_elements());
+ CHECK(map0.get_capacity() == map1.get_capacity());
+ CHECK(*map0.lookup_ptr(0) == *map1.lookup_ptr(0));
+ }
+ CHECK(Memory::get_mem_usage() == pre_mem);
+}
+
+TEST_CASE("[OAHashMap] Non-trivial types") {
+ uint64_t pre_mem = Memory::get_mem_usage();
+ {
+ OAHashMap<String, Ref<Texture2D>> map1;
+ const uint32_t count = 10;
+ for (uint32_t i = 0; i < count; i++) {
+ String string = "qwerty";
+ string += itos(i);
+ Ref<Texture2D> ref_texture_2d;
+
+ map1.set(string, ref_texture_2d);
+ Ref<Texture2D> map_vec = *map1.lookup_ptr(string);
+ CHECK(map_vec == ref_texture_2d);
+ }
+ OAHashMap<String, Ref<Texture2D>> map1copy(map1);
+ CHECK(map1copy.has(String("qwerty0")));
+ map1copy = map1;
+ CHECK(map1copy.has(String("qwerty2")));
+
+ OAHashMap<int64_t, Vector4 *> map2;
+
+ for (uint32_t i = 0; i < count; i++) {
+ Vector4 *vec = memnew(Vector4);
+ vec->x = 10;
+ vec->y = 12;
+ vec->z = 151;
+ vec->w = -13;
+ map2.set(i, vec);
+ Vector4 *p = nullptr;
+ map2.lookup(i, p);
+ CHECK(*p == *vec);
+ }
+
+ OAHashMap<int64_t, Vector4 *> map3(map2);
+ for (OAHashMap<int64_t, Vector4 *>::Iterator it = map2.iter(); it.valid; it = map2.next_iter(it)) {
+ memdelete(*(it.value));
+ }
+ }
+ CHECK(Memory::get_mem_usage() == pre_mem);
+}
+
+} // namespace TestOAHashMap
+
+#endif // TEST_OA_HASH_MAP_H
diff --git a/tests/core/threads/test_worker_thread_pool.h b/tests/core/threads/test_worker_thread_pool.h
index e9a762b57b..0a0291d11b 100644
--- a/tests/core/threads/test_worker_thread_pool.h
+++ b/tests/core/threads/test_worker_thread_pool.h
@@ -38,6 +38,7 @@
namespace TestWorkerThreadPool {
static LocalVector<SafeNumeric<int>> counter;
+static SafeFlag exit;
static void static_test(void *p_arg) {
counter[(uint64_t)p_arg].increment();
@@ -106,6 +107,72 @@ TEST_CASE("[WorkerThreadPool] Process elements using group tasks") {
}
}
+static void static_test_daemon(void *p_arg) {
+ while (!exit.is_set()) {
+ counter[0].add(1);
+ WorkerThreadPool::get_singleton()->yield();
+ }
+}
+
+static void static_busy_task(void *p_arg) {
+ while (!exit.is_set()) {
+ OS::get_singleton()->delay_usec(1);
+ }
+}
+
+static void static_legit_task(void *p_arg) {
+ *((bool *)p_arg) = counter[0].get() > 0;
+ counter[1].add(1);
+}
+
+TEST_CASE("[WorkerThreadPool] Run a yielding daemon as the only hope for other tasks to run") {
+ exit.clear();
+ counter.clear();
+ counter.resize(2);
+
+ WorkerThreadPool::TaskID daemon_task_id = WorkerThreadPool::get_singleton()->add_native_task(static_test_daemon, nullptr, true);
+
+ int num_threads = WorkerThreadPool::get_singleton()->get_thread_count();
+
+ // Keep all the other threads busy.
+ LocalVector<WorkerThreadPool::TaskID> task_ids;
+ for (int i = 0; i < num_threads - 1; i++) {
+ task_ids.push_back(WorkerThreadPool::get_singleton()->add_native_task(static_busy_task, nullptr, true));
+ }
+
+ LocalVector<WorkerThreadPool::TaskID> legit_task_ids;
+ LocalVector<bool> legit_task_needed_yield;
+ int legit_tasks_count = num_threads * 4;
+ legit_task_needed_yield.resize(legit_tasks_count);
+ for (int i = 0; i < legit_tasks_count; i++) {
+ legit_task_needed_yield[i] = false;
+ task_ids.push_back(WorkerThreadPool::get_singleton()->add_native_task(static_legit_task, &legit_task_needed_yield[i], i >= legit_tasks_count / 2));
+ }
+
+ while (counter[1].get() != legit_tasks_count) {
+ OS::get_singleton()->delay_usec(1);
+ }
+
+ exit.set();
+ for (uint32_t i = 0; i < task_ids.size(); i++) {
+ WorkerThreadPool::get_singleton()->wait_for_task_completion(task_ids[i]);
+ }
+ WorkerThreadPool::get_singleton()->notify_yield_over(daemon_task_id);
+ WorkerThreadPool::get_singleton()->wait_for_task_completion(daemon_task_id);
+
+ CHECK_MESSAGE(counter[0].get() > 0, "Daemon task should have looped at least once.");
+ CHECK_MESSAGE(counter[1].get() == legit_tasks_count, "All legit tasks should have been able to run.");
+
+ bool all_needed_yield = true;
+ for (int i = 0; i < legit_tasks_count; i++) {
+ if (!legit_task_needed_yield[i]) {
+ all_needed_yield = false;
+ break;
+ }
+ }
+ CHECK_MESSAGE(all_needed_yield, "All legit tasks should have needed the daemon yielding to run.");
+}
+
} // namespace TestWorkerThreadPool
#endif // TEST_WORKER_THREAD_POOL_H
diff --git a/tests/core/variant/test_array.h b/tests/core/variant/test_array.h
index ea61ae2a02..c54854e4d7 100644
--- a/tests/core/variant/test_array.h
+++ b/tests/core/variant/test_array.h
@@ -545,6 +545,58 @@ TEST_CASE("[Array] Recursive self comparison") {
a2.clear();
}
+TEST_CASE("[Array] Iteration") {
+ Array a1 = build_array(1, 2, 3);
+ Array a2 = build_array(1, 2, 3);
+
+ int idx = 0;
+ for (Variant &E : a1) {
+ CHECK_EQ(int(a2[idx]), int(E));
+ idx++;
+ }
+
+ CHECK_EQ(idx, a1.size());
+
+ idx = 0;
+
+ for (const Variant &E : (const Array &)a1) {
+ CHECK_EQ(int(a2[idx]), int(E));
+ idx++;
+ }
+
+ CHECK_EQ(idx, a1.size());
+
+ a1.clear();
+}
+
+TEST_CASE("[Array] Iteration and modification") {
+ Array a1 = build_array(1, 2, 3);
+ Array a2 = build_array(2, 3, 4);
+ Array a3 = build_array(1, 2, 3);
+ Array a4 = build_array(1, 2, 3);
+ a3.make_read_only();
+
+ int idx = 0;
+ for (Variant &E : a1) {
+ E = a2[idx];
+ idx++;
+ }
+
+ CHECK_EQ(a1, a2);
+
+ // Ensure read-only is respected.
+ idx = 0;
+ for (Variant &E : a3) {
+ E = a2[idx];
+ }
+
+ CHECK_EQ(a3, a4);
+
+ a1.clear();
+ a2.clear();
+ a4.clear();
+}
+
} // namespace TestArray
#endif // TEST_ARRAY_H
diff --git a/tests/scene/test_camera_2d.h b/tests/scene/test_camera_2d.h
new file mode 100644
index 0000000000..f03a4aed53
--- /dev/null
+++ b/tests/scene/test_camera_2d.h
@@ -0,0 +1,318 @@
+/**************************************************************************/
+/* test_camera_2d.h */
+/**************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/**************************************************************************/
+
+#ifndef TEST_CAMERA_2D_H
+#define TEST_CAMERA_2D_H
+
+#include "scene/2d/camera_2d.h"
+#include "scene/main/viewport.h"
+#include "scene/main/window.h"
+#include "tests/test_macros.h"
+
+namespace TestCamera2D {
+
+TEST_CASE("[SceneTree][Camera2D] Getters and setters") {
+ Camera2D *test_camera = memnew(Camera2D);
+
+ SUBCASE("AnchorMode") {
+ test_camera->set_anchor_mode(Camera2D::AnchorMode::ANCHOR_MODE_FIXED_TOP_LEFT);
+ CHECK(test_camera->get_anchor_mode() == Camera2D::AnchorMode::ANCHOR_MODE_FIXED_TOP_LEFT);
+ test_camera->set_anchor_mode(Camera2D::AnchorMode::ANCHOR_MODE_DRAG_CENTER);
+ CHECK(test_camera->get_anchor_mode() == Camera2D::AnchorMode::ANCHOR_MODE_DRAG_CENTER);
+ }
+
+ SUBCASE("ProcessCallback") {
+ test_camera->set_process_callback(Camera2D::Camera2DProcessCallback::CAMERA2D_PROCESS_PHYSICS);
+ CHECK(test_camera->get_process_callback() == Camera2D::Camera2DProcessCallback::CAMERA2D_PROCESS_PHYSICS);
+ test_camera->set_process_callback(Camera2D::Camera2DProcessCallback::CAMERA2D_PROCESS_IDLE);
+ CHECK(test_camera->get_process_callback() == Camera2D::Camera2DProcessCallback::CAMERA2D_PROCESS_IDLE);
+ }
+
+ SUBCASE("Drag") {
+ constexpr float drag_left_margin = 0.8f;
+ constexpr float drag_top_margin = 0.8f;
+ constexpr float drag_right_margin = 0.8f;
+ constexpr float drag_bottom_margin = 0.8f;
+ constexpr float drag_horizontal_offset1 = 0.5f;
+ constexpr float drag_horizontal_offset2 = -0.5f;
+ constexpr float drag_vertical_offset1 = 0.5f;
+ constexpr float drag_vertical_offset2 = -0.5f;
+ test_camera->set_drag_margin(SIDE_LEFT, drag_left_margin);
+ CHECK(test_camera->get_drag_margin(SIDE_LEFT) == drag_left_margin);
+ test_camera->set_drag_margin(SIDE_TOP, drag_top_margin);
+ CHECK(test_camera->get_drag_margin(SIDE_TOP) == drag_top_margin);
+ test_camera->set_drag_margin(SIDE_RIGHT, drag_right_margin);
+ CHECK(test_camera->get_drag_margin(SIDE_RIGHT) == drag_right_margin);
+ test_camera->set_drag_margin(SIDE_BOTTOM, drag_bottom_margin);
+ CHECK(test_camera->get_drag_margin(SIDE_BOTTOM) == drag_bottom_margin);
+ test_camera->set_drag_horizontal_enabled(true);
+ CHECK(test_camera->is_drag_horizontal_enabled());
+ test_camera->set_drag_horizontal_enabled(false);
+ CHECK_FALSE(test_camera->is_drag_horizontal_enabled());
+ test_camera->set_drag_horizontal_offset(drag_horizontal_offset1);
+ CHECK(test_camera->get_drag_horizontal_offset() == drag_horizontal_offset1);
+ test_camera->set_drag_horizontal_offset(drag_horizontal_offset2);
+ CHECK(test_camera->get_drag_horizontal_offset() == drag_horizontal_offset2);
+ test_camera->set_drag_vertical_enabled(true);
+ CHECK(test_camera->is_drag_vertical_enabled());
+ test_camera->set_drag_vertical_enabled(false);
+ CHECK_FALSE(test_camera->is_drag_vertical_enabled());
+ test_camera->set_drag_vertical_offset(drag_vertical_offset1);
+ CHECK(test_camera->get_drag_vertical_offset() == drag_vertical_offset1);
+ test_camera->set_drag_vertical_offset(drag_vertical_offset2);
+ CHECK(test_camera->get_drag_vertical_offset() == drag_vertical_offset2);
+ }
+
+ SUBCASE("Drawing") {
+ test_camera->set_margin_drawing_enabled(true);
+ CHECK(test_camera->is_margin_drawing_enabled());
+ test_camera->set_margin_drawing_enabled(false);
+ CHECK_FALSE(test_camera->is_margin_drawing_enabled());
+ test_camera->set_limit_drawing_enabled(true);
+ CHECK(test_camera->is_limit_drawing_enabled());
+ test_camera->set_limit_drawing_enabled(false);
+ CHECK_FALSE(test_camera->is_limit_drawing_enabled());
+ test_camera->set_screen_drawing_enabled(true);
+ CHECK(test_camera->is_screen_drawing_enabled());
+ test_camera->set_screen_drawing_enabled(false);
+ CHECK_FALSE(test_camera->is_screen_drawing_enabled());
+ }
+
+ SUBCASE("Enabled") {
+ test_camera->set_enabled(true);
+ CHECK(test_camera->is_enabled());
+ test_camera->set_enabled(false);
+ CHECK_FALSE(test_camera->is_enabled());
+ }
+
+ SUBCASE("Rotation") {
+ constexpr float rotation_smoothing_speed = 20.0f;
+ test_camera->set_ignore_rotation(true);
+ CHECK(test_camera->is_ignoring_rotation());
+ test_camera->set_ignore_rotation(false);
+ CHECK_FALSE(test_camera->is_ignoring_rotation());
+ test_camera->set_rotation_smoothing_enabled(true);
+ CHECK(test_camera->is_rotation_smoothing_enabled());
+ test_camera->set_rotation_smoothing_speed(rotation_smoothing_speed);
+ CHECK(test_camera->get_rotation_smoothing_speed() == rotation_smoothing_speed);
+ }
+
+ SUBCASE("Zoom") {
+ const Vector2 zoom = Vector2(4, 4);
+ test_camera->set_zoom(zoom);
+ CHECK(test_camera->get_zoom() == zoom);
+ }
+
+ SUBCASE("Offset") {
+ const Vector2 offset = Vector2(100, 100);
+ test_camera->set_offset(offset);
+ CHECK(test_camera->get_offset() == offset);
+ }
+
+ SUBCASE("Limit") {
+ constexpr int limit_left = 100;
+ constexpr int limit_top = 100;
+ constexpr int limit_right = 100;
+ constexpr int limit_bottom = 100;
+ test_camera->set_limit_smoothing_enabled(true);
+ CHECK(test_camera->is_limit_smoothing_enabled());
+ test_camera->set_limit_smoothing_enabled(false);
+ CHECK_FALSE(test_camera->is_limit_smoothing_enabled());
+ test_camera->set_limit(SIDE_LEFT, limit_left);
+ CHECK(test_camera->get_limit(SIDE_LEFT) == limit_left);
+ test_camera->set_limit(SIDE_TOP, limit_top);
+ CHECK(test_camera->get_limit(SIDE_TOP) == limit_top);
+ test_camera->set_limit(SIDE_RIGHT, limit_right);
+ CHECK(test_camera->get_limit(SIDE_RIGHT) == limit_right);
+ test_camera->set_limit(SIDE_BOTTOM, limit_bottom);
+ CHECK(test_camera->get_limit(SIDE_BOTTOM) == limit_bottom);
+ }
+
+ SUBCASE("Position") {
+ constexpr float smoothing_speed = 20.0f;
+ test_camera->set_position_smoothing_enabled(true);
+ CHECK(test_camera->is_position_smoothing_enabled());
+ test_camera->set_position_smoothing_speed(smoothing_speed);
+ CHECK(test_camera->get_position_smoothing_speed() == smoothing_speed);
+ }
+
+ memdelete(test_camera);
+}
+
+TEST_CASE("[SceneTree][Camera2D] Camera positioning") {
+ SubViewport *mock_viewport = memnew(SubViewport);
+ Camera2D *test_camera = memnew(Camera2D);
+
+ mock_viewport->set_size(Vector2(400, 200));
+ SceneTree::get_singleton()->get_root()->add_child(mock_viewport);
+ mock_viewport->add_child(test_camera);
+
+ SUBCASE("Anchor mode") {
+ test_camera->set_anchor_mode(Camera2D::ANCHOR_MODE_DRAG_CENTER);
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(0, 0)));
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 0)));
+
+ test_camera->set_anchor_mode(Camera2D::ANCHOR_MODE_FIXED_TOP_LEFT);
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(200, 100)));
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 0)));
+ }
+
+ SUBCASE("Offset") {
+ test_camera->set_offset(Vector2(100, 100));
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(100, 100)));
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 0)));
+
+ test_camera->set_offset(Vector2(-100, 300));
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(-100, 300)));
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 0)));
+
+ test_camera->set_offset(Vector2(0, 0));
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(0, 0)));
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 0)));
+ }
+
+ SUBCASE("Limits") {
+ test_camera->set_limit(SIDE_LEFT, 100);
+ test_camera->set_limit(SIDE_TOP, 50);
+
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(300, 150)));
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 0)));
+
+ test_camera->set_limit(SIDE_LEFT, 0);
+ test_camera->set_limit(SIDE_TOP, 0);
+
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(200, 100)));
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 0)));
+ }
+
+ SUBCASE("Drag") {
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(0, 0)));
+
+ // horizontal
+ test_camera->set_drag_horizontal_enabled(true);
+ test_camera->set_drag_margin(SIDE_RIGHT, 0.5);
+
+ test_camera->set_position(Vector2(100, 100));
+ test_camera->force_update_scroll();
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 100)));
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(0, 100)));
+ test_camera->set_position(Vector2(101, 101));
+ test_camera->force_update_scroll();
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(1, 101)));
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(1, 101)));
+
+ // test align
+ test_camera->set_position(Vector2(0, 0));
+ test_camera->align();
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(0, 0)));
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(0, 0)));
+
+ // vertical
+ test_camera->set_drag_vertical_enabled(true);
+ test_camera->set_drag_horizontal_enabled(false);
+ test_camera->set_drag_margin(SIDE_TOP, 0.3);
+
+ test_camera->set_position(Vector2(200, -20));
+ test_camera->force_update_scroll();
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(200, 0)));
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(200, 0)));
+ test_camera->set_position(Vector2(250, -55));
+ test_camera->force_update_scroll();
+ CHECK(test_camera->get_camera_position().is_equal_approx(Vector2(250, -25)));
+ CHECK(test_camera->get_camera_screen_center().is_equal_approx(Vector2(250, -25)));
+ }
+
+ memdelete(test_camera);
+ memdelete(mock_viewport);
+}
+
+TEST_CASE("[SceneTree][Camera2D] Transforms") {
+ SubViewport *mock_viewport = memnew(SubViewport);
+ Camera2D *test_camera = memnew(Camera2D);
+
+ mock_viewport->set_size(Vector2(400, 200));
+ SceneTree::get_singleton()->get_root()->add_child(mock_viewport);
+ mock_viewport->add_child(test_camera);
+
+ SUBCASE("Default camera") {
+ Transform2D xform = mock_viewport->get_canvas_transform();
+ // x,y are basis vectors, origin = screen center
+ Transform2D test_xform = Transform2D(Vector2(1, 0), Vector2(0, 1), Vector2(200, 100));
+ CHECK(xform.is_equal_approx(test_xform));
+ }
+
+ SUBCASE("Zoom") {
+ test_camera->set_zoom(Vector2(0.5, 2));
+ Transform2D xform = mock_viewport->get_canvas_transform();
+ Transform2D test_xform = Transform2D(Vector2(0.5, 0), Vector2(0, 2), Vector2(200, 100));
+ CHECK(xform.is_equal_approx(test_xform));
+
+ test_camera->set_zoom(Vector2(10, 10));
+ xform = mock_viewport->get_canvas_transform();
+ test_xform = Transform2D(Vector2(10, 0), Vector2(0, 10), Vector2(200, 100));
+ CHECK(xform.is_equal_approx(test_xform));
+
+ test_camera->set_zoom(Vector2(1, 1));
+ xform = mock_viewport->get_canvas_transform();
+ test_xform = Transform2D(Vector2(1, 0), Vector2(0, 1), Vector2(200, 100));
+ CHECK(xform.is_equal_approx(test_xform));
+ }
+
+ SUBCASE("Rotation") {
+ test_camera->set_rotation(Math_PI / 2);
+ Transform2D xform = mock_viewport->get_canvas_transform();
+ Transform2D test_xform = Transform2D(Vector2(1, 0), Vector2(0, 1), Vector2(200, 100));
+ CHECK(xform.is_equal_approx(test_xform));
+
+ test_camera->set_ignore_rotation(false);
+ xform = mock_viewport->get_canvas_transform();
+ test_xform = Transform2D(Vector2(0, -1), Vector2(1, 0), Vector2(200, 100));
+ CHECK(xform.is_equal_approx(test_xform));
+
+ test_camera->set_rotation(-1 * Math_PI);
+ test_camera->force_update_scroll();
+ xform = mock_viewport->get_canvas_transform();
+ test_xform = Transform2D(Vector2(-1, 0), Vector2(0, -1), Vector2(200, 100));
+ CHECK(xform.is_equal_approx(test_xform));
+
+ test_camera->set_rotation(0);
+ test_camera->force_update_scroll();
+ xform = mock_viewport->get_canvas_transform();
+ test_xform = Transform2D(Vector2(1, 0), Vector2(0, 1), Vector2(200, 100));
+ CHECK(xform.is_equal_approx(test_xform));
+ }
+
+ memdelete(test_camera);
+ memdelete(mock_viewport);
+}
+
+} // namespace TestCamera2D
+
+#endif // TEST_CAMERA_2D_H
diff --git a/tests/scene/test_code_edit.h b/tests/scene/test_code_edit.h
index bc2f7f51b1..b0a46b8107 100644
--- a/tests/scene/test_code_edit.h
+++ b/tests/scene/test_code_edit.h
@@ -3520,6 +3520,7 @@ TEST_CASE("[SceneTree][CodeEdit] completion") {
/* Single click selects. */
caret_pos.y += code_edit->get_line_height() * 2;
SEND_GUI_MOUSE_BUTTON_EVENT(caret_pos, MouseButton::LEFT, MouseButtonMask::LEFT, Key::NONE);
+ SEND_GUI_MOUSE_BUTTON_RELEASED_EVENT(caret_pos, MouseButton::LEFT, MouseButtonMask::NONE, Key::NONE);
CHECK(code_edit->get_code_completion_selected_index() == 2);
/* Double click inserts. */
diff --git a/tests/scene/test_navigation_region_2d.h b/tests/scene/test_navigation_region_2d.h
index 4574893c8d..fcb5aeacbe 100644
--- a/tests/scene/test_navigation_region_2d.h
+++ b/tests/scene/test_navigation_region_2d.h
@@ -41,7 +41,7 @@ namespace TestNavigationRegion2D {
TEST_SUITE("[Navigation]") {
TEST_CASE("[SceneTree][NavigationRegion2D] New region should have valid RID") {
NavigationRegion2D *region_node = memnew(NavigationRegion2D);
- CHECK(region_node->get_region_rid().is_valid());
+ CHECK(region_node->get_rid().is_valid());
memdelete(region_node);
}
}
diff --git a/tests/scene/test_navigation_region_3d.h b/tests/scene/test_navigation_region_3d.h
index 372f6dc505..0b20b3a1b2 100644
--- a/tests/scene/test_navigation_region_3d.h
+++ b/tests/scene/test_navigation_region_3d.h
@@ -43,7 +43,7 @@ namespace TestNavigationRegion3D {
TEST_SUITE("[Navigation]") {
TEST_CASE("[SceneTree][NavigationRegion3D] New region should have valid RID") {
NavigationRegion3D *region_node = memnew(NavigationRegion3D);
- CHECK(region_node->get_region_rid().is_valid());
+ CHECK(region_node->get_rid().is_valid());
memdelete(region_node);
}
@@ -71,15 +71,6 @@ TEST_SUITE("[Navigation]") {
CHECK_NE(navigation_mesh->get_vertices().size(), 0);
}
- // Race condition is present in the below subcase, but baking should take many
- // orders of magnitude longer than basic checks on the main thread, so it's fine.
- SUBCASE("Asynchronous bake should not be immediate") {
- navigation_region->bake_navigation_mesh(true);
- CHECK(navigation_region->is_baking());
- CHECK_EQ(navigation_mesh->get_polygon_count(), 0);
- CHECK_EQ(navigation_mesh->get_vertices().size(), 0);
- }
-
memdelete(mesh_instance);
memdelete(navigation_region);
memdelete(node_3d);
diff --git a/tests/servers/test_navigation_server_3d.h b/tests/servers/test_navigation_server_3d.h
index 827a1bed17..8778ea86a6 100644
--- a/tests/servers/test_navigation_server_3d.h
+++ b/tests/servers/test_navigation_server_3d.h
@@ -764,6 +764,8 @@ TEST_SUITE("[Navigation]") {
navigation_server->process(0.0); // Give server some cycles to commit.
}
+ // FIXME: The race condition mentioned below is actually a problem and fails on CI (GH-90613).
+ /*
TEST_CASE("[NavigationServer3D] Server should be able to bake asynchronously") {
NavigationServer3D *navigation_server = NavigationServer3D::get_singleton();
Ref<NavigationMesh> navigation_mesh = memnew(NavigationMesh);
@@ -781,6 +783,7 @@ TEST_SUITE("[Navigation]") {
CHECK_EQ(navigation_mesh->get_polygon_count(), 0);
CHECK_EQ(navigation_mesh->get_vertices().size(), 0);
}
+ */
}
} //namespace TestNavigationServer3D
diff --git a/tests/test_main.cpp b/tests/test_main.cpp
index 24eb84127b..56bd8739c6 100644
--- a/tests/test_main.cpp
+++ b/tests/test_main.cpp
@@ -44,6 +44,7 @@
#include "tests/core/io/test_file_access.h"
#include "tests/core/io/test_http_client.h"
#include "tests/core/io/test_image.h"
+#include "tests/core/io/test_ip.h"
#include "tests/core/io/test_json.h"
#include "tests/core/io/test_marshalls.h"
#include "tests/core/io/test_pck_packer.h"
@@ -85,6 +86,7 @@
#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_paged_array.h"
#include "tests/core/templates/test_rid.h"
#include "tests/core/templates/test_vector.h"
@@ -98,9 +100,9 @@
#include "tests/core/variant/test_variant.h"
#include "tests/core/variant/test_variant_utility.h"
#include "tests/scene/test_animation.h"
-#include "tests/scene/test_arraymesh.h"
#include "tests/scene/test_audio_stream_wav.h"
#include "tests/scene/test_bit_map.h"
+#include "tests/scene/test_camera_2d.h"
#include "tests/scene/test_code_edit.h"
#include "tests/scene/test_color_picker.h"
#include "tests/scene/test_control.h"
@@ -124,6 +126,7 @@
#include "tests/test_validate_testing.h"
#ifndef _3D_DISABLED
+#include "tests/scene/test_arraymesh.h"
#include "tests/scene/test_camera_3d.h"
#include "tests/scene/test_navigation_agent_2d.h"
#include "tests/scene/test_navigation_agent_3d.h"