summaryrefslogtreecommitdiffstats
path: root/tests/core
diff options
context:
space:
mode:
Diffstat (limited to 'tests/core')
-rw-r--r--tests/core/io/test_image.h23
-rw-r--r--tests/core/math/test_basis.h94
-rw-r--r--tests/core/string/test_string.h81
-rw-r--r--tests/core/variant/test_variant.h60
4 files changed, 219 insertions, 39 deletions
diff --git a/tests/core/io/test_image.h b/tests/core/io/test_image.h
index 07c7c04e36..945a7e1ba3 100644
--- a/tests/core/io/test_image.h
+++ b/tests/core/io/test_image.h
@@ -403,6 +403,29 @@ TEST_CASE("[Image] Custom mipmaps") {
}
}
+TEST_CASE("[Image] Convert image") {
+ for (int format = Image::FORMAT_RF; format < Image::FORMAT_RGBE9995; format++) {
+ for (int new_format = Image::FORMAT_RF; new_format < Image::FORMAT_RGBE9995; new_format++) {
+ Ref<Image> image = memnew(Image(4, 4, false, (Image::Format)format));
+ image->convert((Image::Format)new_format);
+ String format_string = Image::format_names[(Image::Format)format];
+ String new_format_string = Image::format_names[(Image::Format)new_format];
+ format_string = "Error converting from " + format_string + " to " + new_format_string + ".";
+ CHECK_MESSAGE(image->get_format() == new_format, format_string);
+ }
+ }
+
+ Ref<Image> image = memnew(Image(4, 4, false, Image::FORMAT_RGBA8));
+ PackedByteArray image_data = image->get_data();
+ image->convert((Image::Format)-1);
+ CHECK_MESSAGE(image->get_data() == image_data, "Image conversion to invalid type (-1) should not alter image.");
+
+ Ref<Image> image2 = memnew(Image(4, 4, false, Image::FORMAT_RGBA8));
+ image_data = image2->get_data();
+ image2->convert((Image::Format)(Image::FORMAT_MAX + 1));
+ CHECK_MESSAGE(image2->get_data() == image_data, "Image conversion to invalid type (Image::FORMAT_MAX + 1) should not alter image.");
+}
+
} // namespace TestImage
#endif // TEST_IMAGE_H
diff --git a/tests/core/math/test_basis.h b/tests/core/math/test_basis.h
index fcac9a6231..a9bc2e9b99 100644
--- a/tests/core/math/test_basis.h
+++ b/tests/core/math/test_basis.h
@@ -324,6 +324,100 @@ TEST_CASE("[Basis] Is conformal checks") {
CHECK_FALSE_MESSAGE(
Basis(Vector3(Math_SQRT12, Math_SQRT12, 0), Vector3(0, 1, 0), Vector3(0, 0, 1)).is_conformal(),
"Basis with the X axis skewed 45 degrees should not be conformal.");
+
+ CHECK_MESSAGE(
+ Basis(0, 0, 0, 0, 0, 0, 0, 0, 0).is_conformal(),
+ "Edge case: Basis with all zeroes should return true for is_conformal (because a 0 scale is uniform).");
+}
+
+TEST_CASE("[Basis] Is orthogonal checks") {
+ CHECK_MESSAGE(
+ Basis().is_orthogonal(),
+ "Identity Basis should be orthogonal.");
+
+ CHECK_MESSAGE(
+ Basis::from_euler(Vector3(1.2, 3.4, 5.6)).is_orthogonal(),
+ "Basis with only rotation should be orthogonal.");
+
+ CHECK_MESSAGE(
+ Basis::from_scale(Vector3(-1, -1, -1)).is_orthogonal(),
+ "Basis with only a flip should be orthogonal.");
+
+ CHECK_MESSAGE(
+ Basis::from_scale(Vector3(1.2, 3.4, 5.6)).is_orthogonal(),
+ "Basis with only scale should be orthogonal.");
+
+ CHECK_MESSAGE(
+ Basis(Vector3(3, 4, 0), Vector3(4, -3, 0), Vector3(0, 0, 5)).is_orthogonal(),
+ "Basis with a flip, rotation, and uniform scale should be orthogonal.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis(Vector3(Math_SQRT12, Math_SQRT12, 0), Vector3(0, 1, 0), Vector3(0, 0, 1)).is_orthogonal(),
+ "Basis with the X axis skewed 45 degrees should not be orthogonal.");
+
+ CHECK_MESSAGE(
+ Basis(0, 0, 0, 0, 0, 0, 0, 0, 0).is_orthogonal(),
+ "Edge case: Basis with all zeroes should return true for is_orthogonal, since zero vectors are orthogonal to all vectors.");
+}
+
+TEST_CASE("[Basis] Is orthonormal checks") {
+ CHECK_MESSAGE(
+ Basis().is_orthonormal(),
+ "Identity Basis should be orthonormal.");
+
+ CHECK_MESSAGE(
+ Basis::from_euler(Vector3(1.2, 3.4, 5.6)).is_orthonormal(),
+ "Basis with only rotation should be orthonormal.");
+
+ CHECK_MESSAGE(
+ Basis::from_scale(Vector3(-1, -1, -1)).is_orthonormal(),
+ "Basis with only a flip should be orthonormal.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis::from_scale(Vector3(1.2, 3.4, 5.6)).is_orthonormal(),
+ "Basis with only scale should not be orthonormal.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis(Vector3(3, 4, 0), Vector3(4, -3, 0), Vector3(0, 0, 5)).is_orthonormal(),
+ "Basis with a flip, rotation, and uniform scale should not be orthonormal.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis(Vector3(Math_SQRT12, Math_SQRT12, 0), Vector3(0, 1, 0), Vector3(0, 0, 1)).is_orthonormal(),
+ "Basis with the X axis skewed 45 degrees should not be orthonormal.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis(0, 0, 0, 0, 0, 0, 0, 0, 0).is_orthonormal(),
+ "Edge case: Basis with all zeroes should return false for is_orthonormal, since the vectors do not have a length of 1.");
+}
+
+TEST_CASE("[Basis] Is rotation checks") {
+ CHECK_MESSAGE(
+ Basis().is_rotation(),
+ "Identity Basis should be a rotation (a rotation of zero).");
+
+ CHECK_MESSAGE(
+ Basis::from_euler(Vector3(1.2, 3.4, 5.6)).is_rotation(),
+ "Basis with only rotation should be a rotation.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis::from_scale(Vector3(-1, -1, -1)).is_rotation(),
+ "Basis with only a flip should not be a rotation.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis::from_scale(Vector3(1.2, 3.4, 5.6)).is_rotation(),
+ "Basis with only scale should not be a rotation.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis(Vector3(2, 0, 0), Vector3(0, 0.5, 0), Vector3(0, 0, 1)).is_rotation(),
+ "Basis with a squeeze should not be a rotation.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis(Vector3(Math_SQRT12, Math_SQRT12, 0), Vector3(0, 1, 0), Vector3(0, 0, 1)).is_rotation(),
+ "Basis with the X axis skewed 45 degrees should not be a rotation.");
+
+ CHECK_FALSE_MESSAGE(
+ Basis(0, 0, 0, 0, 0, 0, 0, 0, 0).is_rotation(),
+ "Edge case: Basis with all zeroes should return false for is_rotation, because it is not just a rotation (has a scale of 0).");
}
} // namespace TestBasis
diff --git a/tests/core/string/test_string.h b/tests/core/string/test_string.h
index 02349aedc0..8a11491bb2 100644
--- a/tests/core/string/test_string.h
+++ b/tests/core/string/test_string.h
@@ -456,30 +456,93 @@ TEST_CASE("[String] Number to string") {
}
TEST_CASE("[String] String to integer") {
- static const char *nums[4] = { "1237461283", "- 22", "0", " - 1123412" };
- static const int num[4] = { 1237461283, -22, 0, -1123412 };
+ static const char *nums[14] = { "1237461283", "- 22", "0", " - 1123412", "", "10_000_000", "-1_2_3_4", "10__000", " 1 2 34 ", "-0", "007", "--45", "---46", "-7-2" };
+ static const int num[14] = { 1237461283, -22, 0, -1123412, 0, 10000000, -1234, 10000, 1234, 0, 7, 45, -46, -72 };
- for (int i = 0; i < 4; i++) {
+ for (int i = 0; i < 14; i++) {
CHECK(String(nums[i]).to_int() == num[i]);
}
+ CHECK(String("0b1011").to_int() == 1011); // Looks like a binary number, but to_int() handles this as a base-10 number, "b" is just ignored.
+ CHECK(String("0x1012").to_int() == 1012); // Looks like a hexadecimal number, but to_int() handles this as a base-10 number, "x" is just ignored.
+
+ ERR_PRINT_OFF
+ CHECK(String("999999999999999999999999999999999999999999999999999999999").to_int() == INT64_MAX); // Too large, largest possible is returned.
+ CHECK(String("-999999999999999999999999999999999999999999999999999999999").to_int() == INT64_MIN); // Too small, smallest possible is returned.
+ ERR_PRINT_ON
}
TEST_CASE("[String] Hex to integer") {
- static const char *nums[4] = { "0xFFAE", "22", "0", "AADDAD" };
- static const int64_t num[4] = { 0xFFAE, 0x22, 0, 0xAADDAD };
+ static const char *nums[12] = { "0xFFAE", "22", "0", "AADDAD", "0x7FFFFFFFFFFFFFFF", "-0xf", "", "000", "000f", "0xaA", "-ff", "-" };
+ static const int64_t num[12] = { 0xFFAE, 0x22, 0, 0xAADDAD, 0x7FFFFFFFFFFFFFFF, -0xf, 0, 0, 0xf, 0xaa, -0xff, 0x0 };
- for (int i = 0; i < 4; i++) {
+ for (int i = 0; i < 12; i++) {
CHECK(String(nums[i]).hex_to_int() == num[i]);
}
+
+ // Invalid hex strings should return 0.
+ static const char *invalid_nums[15] = { "qwerty", "QWERTY", "0xqwerty", "0x00qwerty", "qwerty00", "0x", "0x__", "__", "x12", "+", " ff", "ff ", "f f", "+ff", "--0x78" };
+
+ ERR_PRINT_OFF
+ for (int i = 0; i < 15; i++) {
+ CHECK(String(invalid_nums[i]).hex_to_int() == 0);
+ }
+
+ CHECK(String("0xFFFFFFFFFFFFFFFFFFFFFFF").hex_to_int() == INT64_MAX); // Too large, largest possible is returned.
+ CHECK(String("-0xFFFFFFFFFFFFFFFFFFFFFFF").hex_to_int() == INT64_MIN); // Too small, smallest possible is returned.
+ ERR_PRINT_ON
+}
+
+TEST_CASE("[String] Bin to integer") {
+ static const char *nums[10] = { "", "0", "0b0", "0b1", "0b", "1", "0b1010", "-0b11", "-1010", "0b0111111111111111111111111111111111111111111111111111111111111111" };
+ static const int64_t num[10] = { 0, 0, 0, 1, 0, 1, 10, -3, -10, 0x7FFFFFFFFFFFFFFF };
+
+ for (int i = 0; i < 10; i++) {
+ CHECK(String(nums[i]).bin_to_int() == num[i]);
+ }
+
+ // Invalid bin strings should return 0. The long "0x11...11" is just too long for a 64 bit int.
+ static const char *invalid_nums[16] = { "qwerty", "QWERTY", "0bqwerty", "0b00qwerty", "qwerty00", "0x__", "0b__", "__", "b12", "+", "-", "0x12ab", " 11", "11 ", "1 1", "--0b11" };
+
+ for (int i = 0; i < 16; i++) {
+ CHECK(String(invalid_nums[i]).bin_to_int() == 0);
+ }
+
+ ERR_PRINT_OFF
+ CHECK(String("0b111111111111111111111111111111111111111111111111111111111111111111111111111111111").bin_to_int() == INT64_MAX); // Too large, largest possible is returned.
+ CHECK(String("-0b111111111111111111111111111111111111111111111111111111111111111111111111111111111").bin_to_int() == INT64_MIN); // Too small, smallest possible is returned.
+ ERR_PRINT_ON
}
TEST_CASE("[String] String to float") {
- static const char *nums[4] = { "-12348298412.2", "0.05", "2.0002", " -0.0001" };
- static const double num[4] = { -12348298412.2, 0.05, 2.0002, -0.0001 };
+ static const char *nums[12] = { "-12348298412.2", "0.05", "2.0002", " -0.0001", "0", "000", "123", "0.0", "000.000", "000.007", "234__", "3..14" };
+ static const double num[12] = { -12348298412.2, 0.05, 2.0002, -0.0001, 0.0, 0.0, 123.0, 0.0, 0.0, 0.007, 234.0, 3.0 };
- for (int i = 0; i < 4; i++) {
+ for (int i = 0; i < 12; i++) {
CHECK(!(ABS(String(nums[i]).to_float() - num[i]) > 0.00001));
}
+
+ // Invalid float strings should return 0.
+ static const char *invalid_nums[6] = { "qwerty", "qwerty123", "0xffff", "0b1010", "--3.13", "__345" };
+
+ for (int i = 0; i < 6; i++) {
+ CHECK(String(invalid_nums[i]).to_float() == 0);
+ }
+
+ // Very large exponents.
+ CHECK(String("1e308").to_float() == 1e308);
+ CHECK(String("-1e308").to_float() == -1e308);
+
+ // Exponent is so high that value is INFINITY/-INFINITY.
+ CHECK(String("1e309").to_float() == INFINITY);
+ CHECK(String("1e511").to_float() == INFINITY);
+ CHECK(String("-1e309").to_float() == -INFINITY);
+ CHECK(String("-1e511").to_float() == -INFINITY);
+
+ // Exponent is so high that a warning message is printed. Value is INFINITY/-INFINITY.
+ ERR_PRINT_OFF
+ CHECK(String("1e512").to_float() == INFINITY);
+ CHECK(String("-1e512").to_float() == -INFINITY);
+ ERR_PRINT_ON
}
TEST_CASE("[String] Slicing") {
diff --git a/tests/core/variant/test_variant.h b/tests/core/variant/test_variant.h
index 93ae3b4c43..54ca06c6c4 100644
--- a/tests/core/variant/test_variant.h
+++ b/tests/core/variant/test_variant.h
@@ -980,45 +980,45 @@ TEST_CASE("[Variant] Assignment To Vec2 from Bool,Int,Float,String,Vec2i,Vec3,Ve
CHECK(basis_v.get_type() == Variant::VECTOR2);
Variant aabb_v = AABB();
- string_v = "Hello";
- aabb_v = string_v;
- CHECK(aabb_v == Variant("Hello"));
- string_v = "Hello there";
- aabb_v = string_v;
- CHECK(aabb_v.get_type() == Variant::STRING);
+ vec2_v = Vector2(2.2f, 3.5f);
+ aabb_v = vec2_v;
+ CHECK(aabb_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ aabb_v = vec2_v;
+ CHECK(aabb_v.get_type() == Variant::VECTOR2);
Variant quaternion_v = Quaternion();
- string_v = "Hello";
- quaternion_v = string_v;
- CHECK(quaternion_v == Variant("Hello"));
- string_v = "Hello there";
- quaternion_v = string_v;
- CHECK(quaternion_v.get_type() == Variant::STRING);
+ vec2_v = Vector2(2.2f, 3.5f);
+ quaternion_v = vec2_v;
+ CHECK(quaternion_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ quaternion_v = vec2_v;
+ CHECK(quaternion_v.get_type() == Variant::VECTOR2);
Variant projection_v = Projection();
- string_v = "Hello";
- projection_v = string_v;
- CHECK(projection_v == Variant("Hello"));
- string_v = "Hello there";
- projection_v = string_v;
- CHECK(projection_v.get_type() == Variant::STRING);
+ vec2_v = Vector2(2.2f, 3.5f);
+ projection_v = vec2_v;
+ CHECK(projection_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ projection_v = vec2_v;
+ CHECK(projection_v.get_type() == Variant::VECTOR2);
Variant rid_v = RID();
- string_v = "Hello";
- rid_v = string_v;
- CHECK(rid_v == Variant("Hello"));
- string_v = "Hello there";
- rid_v = string_v;
- CHECK(rid_v.get_type() == Variant::STRING);
+ vec2_v = Vector2(2.2f, 3.5f);
+ rid_v = vec2_v;
+ CHECK(rid_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ rid_v = vec2_v;
+ CHECK(rid_v.get_type() == Variant::VECTOR2);
Object obj_one = Object();
Variant object_v = &obj_one;
- string_v = "Hello";
- object_v = string_v;
- CHECK(object_v == Variant("Hello"));
- string_v = "Hello there";
- object_v = string_v;
- CHECK(object_v.get_type() == Variant::STRING);
+ vec2_v = Vector2(2.2f, 3.5f);
+ object_v = vec2_v;
+ CHECK(object_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ object_v = vec2_v;
+ CHECK(object_v.get_type() == Variant::VECTOR2);
}
TEST_CASE("[Variant] Assignment To Vec2i from Bool,Int,Float,String,Vec2,Vec3,Vec3i,Vec4,Vec4i,Rect2,Rect2i,Trans2d,Trans3d,Color,Call,Plane,Basis,AABB,Quant,Proj,RID,and Object") {