Sara/terrain-editor
1
0
Fork 0
Code Issues 10 Pull requests Projects 1 Releases Packages Wiki Activity Actions

feat: modules moved and engine moved to submodule

Browse source
This commit is contained in:
Jan van der Weide 2025-04-12 18:40:44 +02:00
parent dfb5e645cd
commit c33d2130cc
5136 changed files with 225275 additions and 64485 deletions
Download patch file Download diff file Expand all files Collapse all files

5
engine/tests/core/string/test_fuzzy_search.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_FUZZY_SEARCH_H
#define TEST_FUZZY_SEARCH_H
#pragma once
#include "core/string/fuzzy_search.h"
#include "tests/test_macros.h"
@ -79,5 +78,3 @@ TEST_CASE("[FuzzySearch] Test fuzzy search results") {
}
} //namespace TestFuzzySearch
#endif // TEST_FUZZY_SEARCH_H

5
engine/tests/core/string/test_node_path.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_NODE_PATH_H
#define TEST_NODE_PATH_H
#pragma once
#include "core/string/node_path.h"
@ -224,5 +223,3 @@ TEST_CASE("[NodePath] Slice") {
}
} // namespace TestNodePath
#endif // TEST_NODE_PATH_H

248
engine/tests/core/string/test_string.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_STRING_H
#define TEST_STRING_H
#pragma once
#include "core/string/ustring.h"
@ -60,7 +59,7 @@ TEST_CASE("[String] Assign from Latin-1 char string (copycon)") {
const String &t1(s);
CHECK(u32scmp(t1.get_data(), U"Sheep") == 0);
String t2 = String("Sheep", 3);
String t2 = String::latin1(Span("Sheep", 3));
CHECK(u32scmp(t2.get_data(), U"She") == 0);
}
@ -88,34 +87,38 @@ TEST_CASE("[String] UTF8") {
/* how can i embed UTF in here? */
static const char32_t u32str[] = { 0x0045, 0x0020, 0x304A, 0x360F, 0x3088, 0x3046, 0x1F3A4, 0 };
static const uint8_t u8str[] = { 0x45, 0x20, 0xE3, 0x81, 0x8A, 0xE3, 0x98, 0x8F, 0xE3, 0x82, 0x88, 0xE3, 0x81, 0x86, 0xF0, 0x9F, 0x8E, 0xA4, 0 };
String s = u32str;
Error err = s.parse_utf8(s.utf8().get_data());
String expected = u32str;
String parsed;
Error err = parsed.append_utf8(expected.utf8().get_data());
CHECK(err == OK);
CHECK(s == u32str);
CHECK(parsed == u32str);
err = s.parse_utf8((const char *)u8str);
parsed.clear();
err = parsed.append_utf8((const char *)u8str);
CHECK(err == OK);
CHECK(s == u32str);
CHECK(parsed == u32str);
CharString cs = (const char *)u8str;
CHECK(String::utf8(cs) == s);
CHECK(String::utf8(cs) == parsed);
}
TEST_CASE("[String] UTF16") {
/* how can i embed UTF in here? */
static const char32_t u32str[] = { 0x0045, 0x0020, 0x304A, 0x360F, 0x3088, 0x3046, 0x1F3A4, 0 };
static const char16_t u16str[] = { 0x0045, 0x0020, 0x304A, 0x360F, 0x3088, 0x3046, 0xD83C, 0xDFA4, 0 };
String s = u32str;
Error err = s.parse_utf16(s.utf16().get_data());
String expected = u32str;
String parsed;
Error err = parsed.append_utf16(expected.utf16().get_data());
CHECK(err == OK);
CHECK(s == u32str);
CHECK(parsed == u32str);
err = s.parse_utf16(u16str);
parsed.clear();
err = parsed.append_utf16(u16str);
CHECK(err == OK);
CHECK(s == u32str);
CHECK(parsed == u32str);
Char16String cs = u16str;
CHECK(String::utf16(cs) == s);
CHECK(String::utf16(cs) == parsed);
}
TEST_CASE("[String] UTF8 with BOM") {
@ -123,7 +126,7 @@ TEST_CASE("[String] UTF8 with BOM") {
static const char32_t u32str[] = { 0x0045, 0x0020, 0x304A, 0x360F, 0x3088, 0x3046, 0x1F3A4, 0 };
static const uint8_t u8str[] = { 0xEF, 0xBB, 0xBF, 0x45, 0x20, 0xE3, 0x81, 0x8A, 0xE3, 0x98, 0x8F, 0xE3, 0x82, 0x88, 0xE3, 0x81, 0x86, 0xF0, 0x9F, 0x8E, 0xA4, 0 };
String s;
Error err = s.parse_utf8((const char *)u8str);
Error err = s.append_utf8((const char *)u8str);
CHECK(err == OK);
CHECK(s == u32str);
@ -137,11 +140,12 @@ TEST_CASE("[String] UTF16 with BOM") {
static const char16_t u16str[] = { 0xFEFF, 0x0020, 0x0045, 0x304A, 0x360F, 0x3088, 0x3046, 0xD83C, 0xDFA4, 0 };
static const char16_t u16str_swap[] = { 0xFFFE, 0x2000, 0x4500, 0x4A30, 0x0F36, 0x8830, 0x4630, 0x3CD8, 0xA4DF, 0 };
String s;
Error err = s.parse_utf16(u16str);
Error err = s.append_utf16(u16str);
CHECK(err == OK);
CHECK(s == u32str);
err = s.parse_utf16(u16str_swap);
s.clear();
err = s.append_utf16(u16str_swap);
CHECK(err == OK);
CHECK(s == u32str);
@ -156,23 +160,23 @@ TEST_CASE("[String] UTF8 with CR") {
const String base = U"Hello darkness\r\nMy old friend\nI've come to talk\rWith you again";
String keep_cr;
Error err = keep_cr.parse_utf8(base.utf8().get_data());
Error err = keep_cr.append_utf8(base.utf8().get_data());
CHECK(err == OK);
CHECK(keep_cr == base);
String no_cr;
err = no_cr.parse_utf8(base.utf8().get_data(), -1, true); // Skip CR.
err = no_cr.append_utf8(base.utf8().get_data(), -1, true); // Skip CR.
CHECK(err == OK);
CHECK(no_cr == base.replace("\r", ""));
}
TEST_CASE("[String] Invalid UTF8 (non-standard)") {
TEST_CASE("[String] Invalid UTF8 (non shortest form sequence)") {
ERR_PRINT_OFF
static const uint8_t u8str[] = { 0x45, 0xE3, 0x81, 0x8A, 0xE3, 0x82, 0x88, 0xE3, 0x81, 0x86, 0xF0, 0x9F, 0x8E, 0xA4, 0xF0, 0x82, 0x82, 0xAC, 0xED, 0xA0, 0x81, 0 };
// + +2 +2 +2 +3 overlong +3 unpaired +2
static const char32_t u32str[] = { 0x45, 0x304A, 0x3088, 0x3046, 0x1F3A4, 0x20AC, 0xFFFD, 0 };
// Examples from the unicode standard : 3.9 Unicode Encoding Forms - Table 3.8.
static const uint8_t u8str[] = { 0xC0, 0xAF, 0xE0, 0x80, 0xBF, 0xF0, 0x81, 0x82, 0x41, 0 };
static const char32_t u32str[] = { 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x41, 0 };
String s;
Error err = s.parse_utf8((const char *)u8str);
Error err = s.append_utf8((const char *)u8str);
CHECK(err == ERR_INVALID_DATA);
CHECK(s == u32str);
@ -181,13 +185,43 @@ TEST_CASE("[String] Invalid UTF8 (non-standard)") {
ERR_PRINT_ON
}
TEST_CASE("[String] Invalid UTF8 (unrecoverable)") {
TEST_CASE("[String] Invalid UTF8 (ill formed sequences for surrogates)") {
ERR_PRINT_OFF
static const uint8_t u8str[] = { 0x45, 0xE3, 0x81, 0x8A, 0x8F, 0xE3, 0xE3, 0x98, 0x8F, 0xE3, 0x82, 0x88, 0xE3, 0x81, 0x86, 0xC0, 0x80, 0xF0, 0x9F, 0x8E, 0xA4, 0xF0, 0x82, 0x82, 0xAC, 0xED, 0xA0, 0x81, 0 };
// + +2 inv +2 inv inv inv +2 +2 ovl NUL +1 +3 overlong +3 unpaired +2
static const char32_t u32str[] = { 0x45, 0x304A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x3088, 0x3046, 0xFFFD, 0x1F3A4, 0x20AC, 0xFFFD, 0 };
// Examples from the unicode standard : 3.9 Unicode Encoding Forms - Table 3.9.
static const uint8_t u8str[] = { 0xED, 0xA0, 0x80, 0xED, 0xBF, 0xBF, 0xED, 0xAF, 0x41, 0 };
static const char32_t u32str[] = { 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x41, 0 };
String s;
Error err = s.parse_utf8((const char *)u8str);
Error err = s.append_utf8((const char *)u8str);
CHECK(err == ERR_INVALID_DATA);
CHECK(s == u32str);
CharString cs = (const char *)u8str;
CHECK(String::utf8(cs) == s);
ERR_PRINT_ON
}
TEST_CASE("[String] Invalid UTF8 (other ill formed sequences)") {
ERR_PRINT_OFF
// Examples from the unicode standard : 3.9 Unicode Encoding Forms - Table 3.10.
static const uint8_t u8str[] = { 0xF4, 0x91, 0x92, 0x93, 0xFF, 0x41, 0x80, 0xBF, 0x42, 0 };
static const char32_t u32str[] = { 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x41, 0xFFFD, 0xFFFD, 0x42, 0 };
String s;
Error err = s.append_utf8((const char *)u8str);
CHECK(err == ERR_INVALID_DATA);
CHECK(s == u32str);
CharString cs = (const char *)u8str;
CHECK(String::utf8(cs) == s);
ERR_PRINT_ON
}
TEST_CASE("[String] Invalid UTF8 (truncated sequences)") {
ERR_PRINT_OFF
// Examples from the unicode standard : 3.9 Unicode Encoding Forms - Table 3.11.
static const uint8_t u8str[] = { 0xE1, 0x80, 0xE2, 0xF0, 0x91, 0x92, 0xF1, 0xBF, 0x41, 0 };
static const char32_t u32str[] = { 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x41, 0 };
String s;
Error err = s.append_utf8((const char *)u8str);
CHECK(err == ERR_INVALID_DATA);
CHECK(s == u32str);
@ -202,7 +236,7 @@ TEST_CASE("[String] Invalid UTF16 (non-standard)") {
// + + + + unpaired
static const char32_t u32str[] = { 0x0045, 0x304A, 0x3088, 0x3046, 0xDFA4, 0 };
String s;
Error err = s.parse_utf16(u16str);
Error err = s.append_utf16(u16str);
CHECK(err == ERR_PARSE_ERROR);
CHECK(s == u32str);
@ -442,6 +476,27 @@ TEST_CASE("[String] Find and replace") {
MULTICHECK_STRING_STRING_EQ(s, replacen, "Y", "Y", "HappY BirthdaY, Anna!");
}
TEST_CASE("[String] replace_char") {
String s = "Banana";
CHECK(s.replace_char('n', 'x') == "Baxaxa");
CHECK(s.replace_char('\0', 'x') == "Banana");
ERR_PRINT_OFF
CHECK(s.replace_char('n', '\0') == "Banana");
ERR_PRINT_ON
}
TEST_CASE("[String] replace_chars") {
String s = "Banana";
CHECK(s.replace_chars(String("Bn"), 'x') == "xaxaxa");
CHECK(s.replace_chars("Bn", 'x') == "xaxaxa");
CHECK(s.replace_chars(String(), 'x') == "Banana");
CHECK(s.replace_chars("", 'x') == "Banana");
ERR_PRINT_OFF
CHECK(s.replace_chars(String("Bn"), '\0') == "Banana");
CHECK(s.replace_chars("Bn", '\0') == "Banana");
ERR_PRINT_ON
}
TEST_CASE("[String] Insertion") {
String s = "Who is Frederic?";
s = s.insert(s.find("?"), " Chopin");
@ -467,6 +522,23 @@ TEST_CASE("[String] Erasing") {
CHECK(s == "Josephine is such a girl!");
}
TEST_CASE("[String] remove_char") {
String s = "Banana";
CHECK(s.remove_char('a') == "Bnn");
CHECK(s.remove_char('\0') == "Banana");
CHECK(s.remove_char('x') == "Banana");
}
TEST_CASE("[String] remove_chars") {
String s = "Banana";
CHECK(s.remove_chars("Ba") == "nn");
CHECK(s.remove_chars(String("Ba")) == "nn");
CHECK(s.remove_chars("") == "Banana");
CHECK(s.remove_chars(String()) == "Banana");
CHECK(s.remove_chars("xy") == "Banana");
CHECK(s.remove_chars(String("xy")) == "Banana");
}
TEST_CASE("[String] Number to string") {
CHECK(String::num(0) == "0.0"); // The method takes double, so always add zeros.
CHECK(String::num(0.0) == "0.0");
@ -507,12 +579,12 @@ TEST_CASE("[String] Number to string") {
#ifdef REAL_T_IS_DOUBLE
CHECK_MESSAGE(String::num_real(real_t(123.456789)) == "123.456789", "Prints the appropriate amount of digits for real_t = double.");
CHECK_MESSAGE(String::num_real(real_t(-123.456789)) == "-123.456789", "Prints the appropriate amount of digits for real_t = double.");
CHECK_MESSAGE(String::num_real(real_t(Math_PI)) == "3.14159265358979", "Prints the appropriate amount of digits for real_t = double.");
CHECK_MESSAGE(String::num_real(real_t(Math::PI)) == "3.14159265358979", "Prints the appropriate amount of digits for real_t = double.");
CHECK_MESSAGE(String::num_real(real_t(3.1415f)) == "3.1414999961853", "Prints more digits of 32-bit float when real_t = double (ones that would be reliable for double) and no trailing zero.");
#else
CHECK_MESSAGE(String::num_real(real_t(123.456789)) == "123.4568", "Prints the appropriate amount of digits for real_t = float.");
CHECK_MESSAGE(String::num_real(real_t(-123.456789)) == "-123.4568", "Prints the appropriate amount of digits for real_t = float.");
CHECK_MESSAGE(String::num_real(real_t(Math_PI)) == "3.141593", "Prints the appropriate amount of digits for real_t = float.");
CHECK_MESSAGE(String::num_real(real_t(Math::PI)) == "3.141593", "Prints the appropriate amount of digits for real_t = float.");
CHECK_MESSAGE(String::num_real(real_t(3.1415f)) == "3.1415", "Prints only reliable digits of 32-bit float when real_t = float.");
#endif // REAL_T_IS_DOUBLE
@ -603,7 +675,7 @@ TEST_CASE("[String] String to float") {
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 < 12; i++) {
CHECK(!(ABS(String(nums[i]).to_float() - num[i]) > 0.00001));
CHECK(!(Math::abs(String(nums[i]).to_float() - num[i]) > 0.00001));
}
// Invalid float strings should return 0.
@ -618,15 +690,15 @@ TEST_CASE("[String] String to float") {
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);
CHECK(String("1e309").to_float() == Math::INF);
CHECK(String("1e511").to_float() == Math::INF);
CHECK(String("-1e309").to_float() == -Math::INF);
CHECK(String("-1e511").to_float() == -Math::INF);
// 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);
CHECK(String("1e512").to_float() == Math::INF);
CHECK(String("-1e512").to_float() == -Math::INF);
ERR_PRINT_ON
}
@ -714,6 +786,14 @@ TEST_CASE("[String] Splitting") {
CHECK(l[i] == slices[i]);
}
}
{
const String s = "Mars Jupiter Saturn Uranus";
const char *slices[2] = { "Mars", "Jupiter Saturn Uranus" };
Vector<String> l = s.split_spaces(1);
for (int i = 0; i < l.size(); i++) {
CHECK(l[i] == slices[i]);
}
}
{
const String s = "1.2;2.3 4.5";
@ -722,14 +802,14 @@ TEST_CASE("[String] Splitting") {
const Vector<double> d_arr = s.split_floats(";");
CHECK(d_arr.size() == 2);
for (int i = 0; i < d_arr.size(); i++) {
CHECK(ABS(d_arr[i] - slices[i]) <= 0.00001);
CHECK(Math::abs(d_arr[i] - slices[i]) <= 0.00001);
}
const Vector<String> keys = { ";", " " };
const Vector<float> f_arr = s.split_floats_mk(keys);
CHECK(f_arr.size() == 3);
for (int i = 0; i < f_arr.size(); i++) {
CHECK(ABS(f_arr[i] - slices[i]) <= 0.00001);
CHECK(Math::abs(f_arr[i] - slices[i]) <= 0.00001);
}
}
@ -740,7 +820,7 @@ TEST_CASE("[String] Splitting") {
const Vector<double> arr = s.split_floats(" ");
CHECK(arr.size() == 10);
for (int i = 0; i < arr.size(); i++) {
CHECK(ABS(arr[i] - slices[i]) <= 0.00001);
CHECK(Math::abs(arr[i] - slices[i]) <= 0.00001);
}
const Vector<String> keys = { ";", " " };
@ -923,7 +1003,7 @@ TEST_CASE("[String] sprintf") {
// Real (infinity) left-padded
format = "fish %11f frog";
args.clear();
args.push_back(INFINITY);
args.push_back(Math::INF);
output = format.sprintf(args, &error);
REQUIRE(error == false);
CHECK(output == String("fish inf frog"));
@ -1047,7 +1127,7 @@ TEST_CASE("[String] sprintf") {
// Vector left-padded with inf/nan
format = "fish %11v frog";
args.clear();
args.push_back(Variant(Vector2(INFINITY, NAN)));
args.push_back(Variant(Vector2(Math::INF, Math::NaN)));
output = format.sprintf(args, &error);
REQUIRE(error == false);
CHECK(output == String("fish ( inf, nan) frog"));
@ -1371,6 +1451,14 @@ TEST_CASE("[String] Capitalize against many strings") {
output = "Snake Snake Case";
CHECK(input.capitalize() == output);
input = "kebab-case";
output = "Kebab Case";
CHECK(input.capitalize() == output);
input = "kebab-kebab-case";
output = "Kebab Kebab Case";
CHECK(input.capitalize() == output);
input = "sha256sum";
output = "Sha 256 Sum";
CHECK(input.capitalize() == output);
@ -1391,6 +1479,14 @@ TEST_CASE("[String] Capitalize against many strings") {
output = "Snake Case Function( Snake Case Arg )";
CHECK(input.capitalize() == output);
input = "kebab-case-function( kebab-case-arg )";
output = "Kebab Case Function( Kebab Case Arg )";
CHECK(input.capitalize() == output);
input = "kebab_case_function( kebab_case_arg )";
output = "Kebab Case Function( Kebab Case Arg )";
CHECK(input.capitalize() == output);
input = U"словоСлово_слово слово";
output = U"Слово Слово Слово Слово";
CHECK(input.capitalize() == output);
@ -1409,35 +1505,37 @@ struct StringCasesTestCase {
const char32_t *camel_case;
const char32_t *pascal_case;
const char32_t *snake_case;
const char32_t *kebab_case;
};
TEST_CASE("[String] Checking case conversion methods") {
StringCasesTestCase test_cases[] = {
/* clang-format off */
{ U"2D", U"2d", U"2d", U"2d" },
{ U"2d", U"2d", U"2d", U"2d" },
{ U"2db", U"2Db", U"2Db", U"2_db" },
{ U"Vector3", U"vector3", U"Vector3", U"vector_3" },
{ U"sha256", U"sha256", U"Sha256", U"sha_256" },
{ U"Node2D", U"node2d", U"Node2d", U"node_2d" },
{ U"RichTextLabel", U"richTextLabel", U"RichTextLabel", U"rich_text_label" },
{ U"HTML5", U"html5", U"Html5", U"html_5" },
{ U"Node2DPosition", U"node2dPosition", U"Node2dPosition", U"node_2d_position" },
{ U"Number2Digits", U"number2Digits", U"Number2Digits", U"number_2_digits" },
{ U"get_property_list", U"getPropertyList", U"GetPropertyList", U"get_property_list" },
{ U"get_camera_2d", U"getCamera2d", U"GetCamera2d", U"get_camera_2d" },
{ U"_physics_process", U"physicsProcess", U"PhysicsProcess", U"_physics_process" },
{ U"bytes2var", U"bytes2Var", U"Bytes2Var", U"bytes_2_var" },
{ U"linear2db", U"linear2Db", U"Linear2Db", U"linear_2_db" },
{ U"sha256sum", U"sha256Sum", U"Sha256Sum", U"sha_256_sum" },
{ U"camelCase", U"camelCase", U"CamelCase", U"camel_case" },
{ U"PascalCase", U"pascalCase", U"PascalCase", U"pascal_case" },
{ U"snake_case", U"snakeCase", U"SnakeCase", U"snake_case" },
{ U"Test TEST test", U"testTestTest", U"TestTestTest", U"test_test_test" },
{ U"словоСлово_слово слово", U"словоСловоСловоСлово", U"СловоСловоСловоСлово", U"слово_слово_слово_слово" },
{ U"λέξηΛέξη_λέξη λέξη", U"λέξηΛέξηΛέξηΛέξη", U"ΛέξηΛέξηΛέξηΛέξη", U"λέξη_λέξη_λέξη_λέξη" },
{ U"բառԲառ_բառ բառ", U"բառԲառԲառԲառ", U"ԲառԲառԲառԲառ", U"բառ_բառ_բառ_բառ" },
{ nullptr, nullptr, nullptr, nullptr },
{ U"2D", U"2d", U"2d", U"2d", U"2d" },
{ U"2d", U"2d", U"2d", U"2d", U"2d" },
{ U"2db", U"2Db", U"2Db", U"2_db", U"2-db" },
{ U"Vector3", U"vector3", U"Vector3", U"vector_3", U"vector-3" },
{ U"sha256", U"sha256", U"Sha256", U"sha_256", U"sha-256" },
{ U"Node2D", U"node2d", U"Node2d", U"node_2d", U"node-2d" },
{ U"RichTextLabel", U"richTextLabel", U"RichTextLabel", U"rich_text_label", U"rich-text-label" },
{ U"HTML5", U"html5", U"Html5", U"html_5", U"html-5" },
{ U"Node2DPosition", U"node2dPosition", U"Node2dPosition", U"node_2d_position", U"node-2d-position" },
{ U"Number2Digits", U"number2Digits", U"Number2Digits", U"number_2_digits", U"number-2-digits" },
{ U"get_property_list", U"getPropertyList", U"GetPropertyList", U"get_property_list", U"get-property-list" },
{ U"get_camera_2d", U"getCamera2d", U"GetCamera2d", U"get_camera_2d", U"get-camera-2d" },
{ U"_physics_process", U"physicsProcess", U"PhysicsProcess", U"_physics_process", U"-physics-process" },
{ U"bytes2var", U"bytes2Var", U"Bytes2Var", U"bytes_2_var", U"bytes-2-var" },
{ U"linear2db", U"linear2Db", U"Linear2Db", U"linear_2_db", U"linear-2-db" },
{ U"sha256sum", U"sha256Sum", U"Sha256Sum", U"sha_256_sum", U"sha-256-sum" },
{ U"camelCase", U"camelCase", U"CamelCase", U"camel_case", U"camel-case" },
{ U"PascalCase", U"pascalCase", U"PascalCase", U"pascal_case", U"pascal-case" },
{ U"snake_case", U"snakeCase", U"SnakeCase", U"snake_case", U"snake-case" },
{ U"kebab-case", U"kebabCase", U"KebabCase", U"kebab_case", U"kebab-case" },
{ U"Test TEST test", U"testTestTest", U"TestTestTest", U"test_test_test", U"test-test-test" },
{ U"словоСлово_слово слово", U"словоСловоСловоСлово", U"СловоСловоСловоСлово", U"слово_слово_слово_слово", U"слово-слово-слово-слово" },
{ U"λέξηΛέξη_λέξη λέξη", U"λέξηΛέξηΛέξηΛέξη", U"ΛέξηΛέξηΛέξηΛέξη", U"λέξη_λέξη_λέξη_λέξη", U"λέξη-λέξη-λέξη-λέξη" },
{ U"բառԲառ_բառ բառ", U"բառԲառԲառԲառ", U"ԲառԲառԲառԲառ", U"բառ_բառ_բառ_բառ", U"բառ-բառ-բառ-բառ" },
{ nullptr, nullptr, nullptr, nullptr, nullptr },
/* clang-format on */
};
@ -1447,6 +1545,7 @@ TEST_CASE("[String] Checking case conversion methods") {
CHECK(input.to_camel_case() == test_cases[idx].camel_case);
CHECK(input.to_pascal_case() == test_cases[idx].pascal_case);
CHECK(input.to_snake_case() == test_cases[idx].snake_case);
CHECK(input.to_kebab_case() == test_cases[idx].kebab_case);
idx++;
}
}
@ -1550,9 +1649,9 @@ TEST_CASE("[String] lstrip and rstrip") {
#undef STRIP_TEST
}
TEST_CASE("[String] Ensuring empty string into parse_utf8 passes empty string") {
TEST_CASE("[String] Ensuring empty string into extend_utf8 passes empty string") {
String empty;
CHECK(empty.parse_utf8(nullptr, -1) == ERR_INVALID_DATA);
CHECK(empty.append_utf8(nullptr, -1) == ERR_INVALID_DATA);
}
TEST_CASE("[String] Cyrillic to_lower()") {
@ -1715,6 +1814,7 @@ TEST_CASE("[String] uri_encode/unescape") {
static const uint8_t u8str[] = { 0x54, 0xC4, 0x93, 0xC5, 0xA1, 0x74, 0x00 };
String x2 = String::utf8((const char *)u8str);
String x3 = U"Tēšt";
String x4 = U"file+name";
CHECK(x1.uri_decode() == x2);
CHECK(x1.uri_decode() == x3);
@ -1724,6 +1824,8 @@ TEST_CASE("[String] uri_encode/unescape") {
CHECK(s.uri_encode() == t);
CHECK(t.uri_decode() == s);
CHECK(x4.uri_file_decode() == x4);
CHECK(x4.uri_decode() == U"file name");
}
TEST_CASE("[String] xml_escape/unescape") {
@ -1896,7 +1998,7 @@ TEST_CASE("[String] Is_*") {
static bool isflt[] = { true, true, true, false, true, true, false, false, false, false, false, false, false, true, true };
static bool isaid[] = { false, false, false, false, false, false, false, false, true, true, false, false, false, false, false };
static bool isuid[] = { false, false, false, false, false, false, false, false, true, true, false, false, true, false, false };
for (unsigned int i = 0; i < sizeof(data) / sizeof(data[0]); i++) {
for (unsigned int i = 0; i < std::size(data); i++) {
String s = String::utf8(data[i]);
CHECK(s.is_numeric() == isnum[i]);
CHECK(s.is_valid_int() == isint[i]);
@ -2103,5 +2205,3 @@ TEST_CASE("[Stress][String] Empty via `is_empty()`") {
}
}
} // namespace TestString
#endif // TEST_STRING_H

5
engine/tests/core/string/test_translation.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_TRANSLATION_H
#define TEST_TRANSLATION_H
#pragma once
#include "core/string/optimized_translation.h"
#include "core/string/translation.h"
@ -201,5 +200,3 @@ TEST_CASE("[TranslationCSV] CSV import") {
#endif // TOOLS_ENABLED
} // namespace TestTranslation
#endif // TEST_TRANSLATION_H

5
engine/tests/core/string/test_translation_server.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_TRANSLATION_SERVER_H
#define TEST_TRANSLATION_SERVER_H
#pragma once
#include "core/string/translation_server.h"
@ -222,5 +221,3 @@ TEST_CASE("[TranslationServer] Comparing locales") {
CHECK(res == 10);
}
} // namespace TestTranslationServer
#endif // TEST_TRANSLATION_SERVER_H