mirror of
https://github.com/RGBCube/serenity
synced 2025-07-28 17:37:47 +00:00
Everywhere: Add sv suffix to strings relying on StringView(char const*)
Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
This commit is contained in:
parent
e5f09ea170
commit
3f3f45580a
762 changed files with 8315 additions and 8316 deletions
|
@ -204,7 +204,7 @@ template<>
|
|||
struct AK::Formatter<B> : Formatter<StringView> {
|
||||
ErrorOr<void> format(FormatBuilder& builder, B)
|
||||
{
|
||||
return Formatter<StringView>::format(builder, "B");
|
||||
return Formatter<StringView>::format(builder, "B"sv);
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -288,7 +288,7 @@ template<>
|
|||
struct AK::Formatter<C> : AK::Formatter<FormatString> {
|
||||
ErrorOr<void> format(FormatBuilder& builder, C c)
|
||||
{
|
||||
return AK::Formatter<FormatString>::format(builder, "C(i={})", c.i);
|
||||
return AK::Formatter<FormatString>::format(builder, "C(i={})"sv, c.i);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
@ -66,7 +66,7 @@ TEST_CASE(should_convert_to_string)
|
|||
|
||||
TEST_CASE(should_make_ipv4_address_from_string)
|
||||
{
|
||||
auto const addr = IPv4Address::from_string("192.168.0.1");
|
||||
auto const addr = IPv4Address::from_string("192.168.0.1"sv);
|
||||
|
||||
EXPECT(addr.has_value());
|
||||
EXPECT_EQ(192, addr.value()[0]);
|
||||
|
@ -77,21 +77,21 @@ TEST_CASE(should_make_ipv4_address_from_string)
|
|||
|
||||
TEST_CASE(should_make_empty_optional_from_bad_string)
|
||||
{
|
||||
auto const addr = IPv4Address::from_string("bad string");
|
||||
auto const addr = IPv4Address::from_string("bad string"sv);
|
||||
|
||||
EXPECT(!addr.has_value());
|
||||
}
|
||||
|
||||
TEST_CASE(should_make_empty_optional_from_out_of_range_values)
|
||||
{
|
||||
auto const addr = IPv4Address::from_string("192.168.0.500");
|
||||
auto const addr = IPv4Address::from_string("192.168.0.500"sv);
|
||||
|
||||
EXPECT(!addr.has_value());
|
||||
}
|
||||
|
||||
TEST_CASE(should_fill_d_octet_from_1_part)
|
||||
{
|
||||
auto const addr = IPv4Address::from_string("1");
|
||||
auto const addr = IPv4Address::from_string("1"sv);
|
||||
|
||||
EXPECT(addr.has_value());
|
||||
EXPECT_EQ(0, addr.value()[0]);
|
||||
|
@ -102,7 +102,7 @@ TEST_CASE(should_fill_d_octet_from_1_part)
|
|||
|
||||
TEST_CASE(should_fill_a_and_d_octets_from_2_parts)
|
||||
{
|
||||
auto const addr = IPv4Address::from_string("192.1");
|
||||
auto const addr = IPv4Address::from_string("192.1"sv);
|
||||
|
||||
EXPECT(addr.has_value());
|
||||
EXPECT_EQ(192, addr.value()[0]);
|
||||
|
@ -113,7 +113,7 @@ TEST_CASE(should_fill_a_and_d_octets_from_2_parts)
|
|||
|
||||
TEST_CASE(should_fill_a_b_d_octets_from_3_parts)
|
||||
{
|
||||
auto const addr = IPv4Address::from_string("192.168.1");
|
||||
auto const addr = IPv4Address::from_string("192.168.1"sv);
|
||||
|
||||
EXPECT(addr.has_value());
|
||||
EXPECT_EQ(192, addr.value()[0]);
|
||||
|
|
|
@ -40,15 +40,15 @@ TEST_CASE(load_form)
|
|||
|
||||
EXPECT(form_json.is_object());
|
||||
|
||||
auto name = form_json.as_object().get("name").to_string();
|
||||
auto name = form_json.as_object().get("name"sv).to_string();
|
||||
|
||||
EXPECT_EQ(name, "Form1");
|
||||
|
||||
auto widgets = form_json.as_object().get("widgets").as_array();
|
||||
auto widgets = form_json.as_object().get("widgets"sv).as_array();
|
||||
|
||||
widgets.for_each([&](JsonValue const& widget_value) {
|
||||
auto& widget_object = widget_value.as_object();
|
||||
auto widget_class = widget_object.get("class").as_string();
|
||||
auto widget_class = widget_object.get("class"sv).as_string();
|
||||
widget_object.for_each_member([&]([[maybe_unused]] auto& property_name, [[maybe_unused]] const JsonValue& property_value) {
|
||||
});
|
||||
});
|
||||
|
@ -56,7 +56,7 @@ TEST_CASE(load_form)
|
|||
|
||||
TEST_CASE(json_empty_string)
|
||||
{
|
||||
auto json = JsonValue::from_string("\"\"").value();
|
||||
auto json = JsonValue::from_string("\"\""sv).value();
|
||||
EXPECT_EQ(json.type(), JsonValue::Type::String);
|
||||
EXPECT_EQ(json.as_string().is_null(), false);
|
||||
EXPECT_EQ(json.as_string().is_empty(), true);
|
||||
|
@ -64,7 +64,7 @@ TEST_CASE(json_empty_string)
|
|||
|
||||
TEST_CASE(json_string)
|
||||
{
|
||||
auto json = JsonValue::from_string("\"A\"").value();
|
||||
auto json = JsonValue::from_string("\"A\""sv).value();
|
||||
EXPECT_EQ(json.type(), JsonValue::Type::String);
|
||||
EXPECT_EQ(json.as_string().is_null(), false);
|
||||
EXPECT_EQ(json.as_string().length(), size_t { 1 });
|
||||
|
@ -73,7 +73,7 @@ TEST_CASE(json_string)
|
|||
|
||||
TEST_CASE(json_utf8_character)
|
||||
{
|
||||
auto json = JsonValue::from_string("\"\\u0041\"").value();
|
||||
auto json = JsonValue::from_string("\"\\u0041\""sv).value();
|
||||
EXPECT_EQ(json.type(), JsonValue::Type::String);
|
||||
EXPECT_EQ(json.as_string().is_null(), false);
|
||||
EXPECT_EQ(json.as_string().length(), size_t { 1 });
|
||||
|
@ -125,12 +125,12 @@ TEST_CASE(json_u64_roundtrip)
|
|||
|
||||
TEST_CASE(json_parse_empty_string)
|
||||
{
|
||||
auto value = JsonValue::from_string("");
|
||||
auto value = JsonValue::from_string(""sv);
|
||||
EXPECT_EQ(value.is_error(), true);
|
||||
}
|
||||
|
||||
TEST_CASE(json_parse_long_decimals)
|
||||
{
|
||||
auto value = JsonValue::from_string("1644452550.6489999294281");
|
||||
auto value = JsonValue::from_string("1644452550.6489999294281"sv);
|
||||
EXPECT_EQ(value.value().as_double(), 1644452550.6489999294281);
|
||||
}
|
||||
|
|
|
@ -12,13 +12,13 @@
|
|||
|
||||
TEST_CASE(relative_path)
|
||||
{
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/abc.txt", "/tmp"), "abc.txt");
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/abc.txt", "/tmp/"), "abc.txt");
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/abc.txt", "/"), "tmp/abc.txt");
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/abc.txt", "/usr"), "/tmp/abc.txt");
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/abc.txt"sv, "/tmp"sv), "abc.txt"sv);
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/abc.txt"sv, "/tmp/"sv), "abc.txt"sv);
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/abc.txt"sv, "/"sv), "tmp/abc.txt"sv);
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/abc.txt"sv, "/usr"sv), "/tmp/abc.txt"sv);
|
||||
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/foo.txt", "tmp"), String {});
|
||||
EXPECT_EQ(LexicalPath::relative_path("tmp/foo.txt", "/tmp"), String {});
|
||||
EXPECT_EQ(LexicalPath::relative_path("/tmp/foo.txt"sv, "tmp"sv), ""sv);
|
||||
EXPECT_EQ(LexicalPath::relative_path("tmp/foo.txt"sv, "/tmp"sv), ""sv);
|
||||
}
|
||||
|
||||
TEST_CASE(regular_absolute_path)
|
||||
|
@ -29,9 +29,9 @@ TEST_CASE(regular_absolute_path)
|
|||
EXPECT_EQ(path.basename(), "foo.txt");
|
||||
EXPECT_EQ(path.title(), "foo");
|
||||
EXPECT_EQ(path.extension(), "txt");
|
||||
EXPECT(path.has_extension(".txt"));
|
||||
EXPECT(path.has_extension("txt"));
|
||||
EXPECT(!path.has_extension("txxt"));
|
||||
EXPECT(path.has_extension(".txt"sv));
|
||||
EXPECT(path.has_extension("txt"sv));
|
||||
EXPECT(!path.has_extension("txxt"sv));
|
||||
EXPECT_EQ(path.parts_view().size(), 3u);
|
||||
EXPECT_EQ(path.parts_view()[0], "home");
|
||||
EXPECT_EQ(path.parts_view()[1], "anon");
|
||||
|
@ -145,41 +145,41 @@ TEST_CASE(has_extension)
|
|||
{
|
||||
{
|
||||
LexicalPath path("/tmp/simple.png");
|
||||
EXPECT(path.has_extension(".png"));
|
||||
EXPECT(path.has_extension(".pnG"));
|
||||
EXPECT(path.has_extension(".PNG"));
|
||||
EXPECT(path.has_extension(".png"sv));
|
||||
EXPECT(path.has_extension(".pnG"sv));
|
||||
EXPECT(path.has_extension(".PNG"sv));
|
||||
}
|
||||
|
||||
{
|
||||
LexicalPath path("/TMP/SIMPLE.PNG");
|
||||
EXPECT(path.has_extension(".png"));
|
||||
EXPECT(path.has_extension(".pnG"));
|
||||
EXPECT(path.has_extension(".PNG"));
|
||||
EXPECT(path.has_extension(".png"sv));
|
||||
EXPECT(path.has_extension(".pnG"sv));
|
||||
EXPECT(path.has_extension(".PNG"sv));
|
||||
}
|
||||
|
||||
{
|
||||
LexicalPath path(".png");
|
||||
EXPECT(path.has_extension(".png"));
|
||||
EXPECT(path.has_extension(".png"sv));
|
||||
}
|
||||
|
||||
{
|
||||
LexicalPath path("png");
|
||||
EXPECT_EQ(path.has_extension(".png"), false);
|
||||
EXPECT_EQ(path.has_extension(".png"sv), false);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE(join)
|
||||
{
|
||||
EXPECT_EQ(LexicalPath::join("anon", "foo.txt").string(), "anon/foo.txt");
|
||||
EXPECT_EQ(LexicalPath::join("/home", "anon/foo.txt").string(), "/home/anon/foo.txt");
|
||||
EXPECT_EQ(LexicalPath::join("/", "foo.txt").string(), "/foo.txt");
|
||||
EXPECT_EQ(LexicalPath::join("/home", "anon", "foo.txt").string(), "/home/anon/foo.txt");
|
||||
EXPECT_EQ(LexicalPath::join("anon"sv, "foo.txt"sv).string(), "anon/foo.txt"sv);
|
||||
EXPECT_EQ(LexicalPath::join("/home"sv, "anon/foo.txt"sv).string(), "/home/anon/foo.txt"sv);
|
||||
EXPECT_EQ(LexicalPath::join("/"sv, "foo.txt"sv).string(), "/foo.txt"sv);
|
||||
EXPECT_EQ(LexicalPath::join("/home"sv, "anon"sv, "foo.txt"sv).string(), "/home/anon/foo.txt"sv);
|
||||
}
|
||||
|
||||
TEST_CASE(append)
|
||||
{
|
||||
LexicalPath path("/home/anon/");
|
||||
auto new_path = path.append("foo.txt");
|
||||
auto new_path = path.append("foo.txt"sv);
|
||||
EXPECT_EQ(new_path.string(), "/home/anon/foo.txt");
|
||||
}
|
||||
|
||||
|
|
|
@ -85,7 +85,7 @@ TEST_CASE(should_string_format)
|
|||
|
||||
TEST_CASE(should_make_mac_address_from_string_numbers)
|
||||
{
|
||||
auto const sut = MACAddress::from_string("01:02:03:04:05:06");
|
||||
auto const sut = MACAddress::from_string("01:02:03:04:05:06"sv);
|
||||
|
||||
EXPECT(sut.has_value());
|
||||
EXPECT_EQ(1, sut.value()[0]);
|
||||
|
@ -98,7 +98,7 @@ TEST_CASE(should_make_mac_address_from_string_numbers)
|
|||
|
||||
TEST_CASE(should_make_mac_address_from_string_letters)
|
||||
{
|
||||
auto const sut = MACAddress::from_string("de:ad:be:ee:ee:ef");
|
||||
auto const sut = MACAddress::from_string("de:ad:be:ee:ee:ef"sv);
|
||||
|
||||
EXPECT(sut.has_value());
|
||||
EXPECT_EQ(u8 { 0xDE }, sut.value()[0]);
|
||||
|
@ -111,14 +111,14 @@ TEST_CASE(should_make_mac_address_from_string_letters)
|
|||
|
||||
TEST_CASE(should_make_empty_optional_from_bad_string)
|
||||
{
|
||||
auto const sut = MACAddress::from_string("bad string");
|
||||
auto const sut = MACAddress::from_string("bad string"sv);
|
||||
|
||||
EXPECT(!sut.has_value());
|
||||
}
|
||||
|
||||
TEST_CASE(should_make_empty_optional_from_out_of_range_values)
|
||||
{
|
||||
auto const sut = MACAddress::from_string("de:ad:be:ee:ee:fz");
|
||||
auto const sut = MACAddress::from_string("de:ad:be:ee:ee:fz"sv);
|
||||
|
||||
EXPECT(!sut.has_value());
|
||||
}
|
||||
|
|
|
@ -71,7 +71,7 @@ TEST_CASE(optional_leak_1)
|
|||
|
||||
TEST_CASE(short_notation)
|
||||
{
|
||||
Optional<StringView> value = "foo";
|
||||
Optional<StringView> value = "foo"sv;
|
||||
|
||||
EXPECT_EQ(value->length(), 3u);
|
||||
EXPECT_EQ(*value, "foo");
|
||||
|
@ -89,9 +89,9 @@ TEST_CASE(comparison_without_values)
|
|||
TEST_CASE(comparison_with_values)
|
||||
{
|
||||
Optional<StringView> opt0;
|
||||
Optional<StringView> opt1 = "foo";
|
||||
Optional<String> opt2 = "foo";
|
||||
Optional<StringView> opt3 = "bar";
|
||||
Optional<StringView> opt1 = "foo"sv;
|
||||
Optional<String> opt2 = "foo"sv;
|
||||
Optional<StringView> opt3 = "bar"sv;
|
||||
EXPECT_NE(opt0, opt1);
|
||||
EXPECT_EQ(opt1, opt2);
|
||||
EXPECT_NE(opt1, opt3);
|
||||
|
@ -103,7 +103,7 @@ TEST_CASE(comparison_to_underlying_types)
|
|||
EXPECT_NE(opt0, String());
|
||||
EXPECT_NE(opt0, "foo");
|
||||
|
||||
Optional<StringView> opt1 = "foo";
|
||||
Optional<StringView> opt1 = "foo"sv;
|
||||
EXPECT_EQ(opt1, "foo");
|
||||
EXPECT_NE(opt1, "bar");
|
||||
EXPECT_EQ(opt1, String("foo"));
|
||||
|
@ -250,7 +250,7 @@ TEST_CASE(move_optional_reference)
|
|||
|
||||
TEST_CASE(short_notation_reference)
|
||||
{
|
||||
StringView test = "foo";
|
||||
StringView test = "foo"sv;
|
||||
Optional<StringView&> value = test;
|
||||
|
||||
EXPECT_EQ(value->length(), 3u);
|
||||
|
@ -259,11 +259,11 @@ TEST_CASE(short_notation_reference)
|
|||
|
||||
TEST_CASE(comparison_reference)
|
||||
{
|
||||
StringView test = "foo";
|
||||
StringView test = "foo"sv;
|
||||
Optional<StringView&> opt0;
|
||||
Optional<StringView const&> opt1 = test;
|
||||
Optional<String> opt2 = "foo";
|
||||
Optional<StringView> opt3 = "bar";
|
||||
Optional<String> opt2 = "foo"sv;
|
||||
Optional<StringView> opt3 = "bar"sv;
|
||||
|
||||
EXPECT_NE(opt0, opt1);
|
||||
EXPECT_EQ(opt1, opt2);
|
||||
|
|
|
@ -47,14 +47,14 @@ TEST_CASE(equal)
|
|||
|
||||
TEST_CASE(compare)
|
||||
{
|
||||
EXPECT("a" < String("b"));
|
||||
EXPECT(!("a" > String("b")));
|
||||
EXPECT("b" > String("a"));
|
||||
EXPECT(!("b" < String("b")));
|
||||
EXPECT("a" >= String("a"));
|
||||
EXPECT(!("a" >= String("b")));
|
||||
EXPECT("a" <= String("a"));
|
||||
EXPECT(!("b" <= String("a")));
|
||||
EXPECT("a"sv < String("b"));
|
||||
EXPECT(!("a"sv > String("b")));
|
||||
EXPECT("b"sv > String("a"));
|
||||
EXPECT(!("b"sv < String("b")));
|
||||
EXPECT("a"sv >= String("a"));
|
||||
EXPECT(!("a"sv >= String("b")));
|
||||
EXPECT("a"sv <= String("a"));
|
||||
EXPECT(!("b"sv <= String("a")));
|
||||
|
||||
EXPECT(String("a") > String());
|
||||
EXPECT(!(String() > String("a")));
|
||||
|
@ -81,25 +81,25 @@ TEST_CASE(index_access)
|
|||
TEST_CASE(starts_with)
|
||||
{
|
||||
String test_string = "ABCDEF";
|
||||
EXPECT(test_string.starts_with("AB"));
|
||||
EXPECT(test_string.starts_with("AB"sv));
|
||||
EXPECT(test_string.starts_with('A'));
|
||||
EXPECT(!test_string.starts_with('B'));
|
||||
EXPECT(test_string.starts_with("ABCDEF"));
|
||||
EXPECT(!test_string.starts_with("DEF"));
|
||||
EXPECT(test_string.starts_with("abc", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!test_string.starts_with("abc", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(test_string.starts_with("ABCDEF"sv));
|
||||
EXPECT(!test_string.starts_with("DEF"sv));
|
||||
EXPECT(test_string.starts_with("abc"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!test_string.starts_with("abc"sv, CaseSensitivity::CaseSensitive));
|
||||
}
|
||||
|
||||
TEST_CASE(ends_with)
|
||||
{
|
||||
String test_string = "ABCDEF";
|
||||
EXPECT(test_string.ends_with("EF"));
|
||||
EXPECT(test_string.ends_with("EF"sv));
|
||||
EXPECT(test_string.ends_with('F'));
|
||||
EXPECT(!test_string.ends_with('E'));
|
||||
EXPECT(test_string.ends_with("ABCDEF"));
|
||||
EXPECT(!test_string.ends_with("ABC"));
|
||||
EXPECT(test_string.ends_with("def", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!test_string.ends_with("def", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(test_string.ends_with("ABCDEF"sv));
|
||||
EXPECT(!test_string.ends_with("ABC"sv));
|
||||
EXPECT(test_string.ends_with("def"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!test_string.ends_with("def"sv, CaseSensitivity::CaseSensitive));
|
||||
}
|
||||
|
||||
TEST_CASE(copy_string)
|
||||
|
@ -155,7 +155,7 @@ TEST_CASE(flystring)
|
|||
FlyString b = a;
|
||||
StringBuilder builder;
|
||||
builder.append('f');
|
||||
builder.append("oo");
|
||||
builder.append("oo"sv);
|
||||
FlyString c = builder.to_string();
|
||||
EXPECT_EQ(a.impl(), b.impl());
|
||||
EXPECT_EQ(a.impl(), c.impl());
|
||||
|
@ -166,40 +166,40 @@ TEST_CASE(replace)
|
|||
{
|
||||
String test_string = "Well, hello Friends!";
|
||||
|
||||
test_string = test_string.replace("Friends", "Testers", ReplaceMode::FirstOnly);
|
||||
test_string = test_string.replace("Friends"sv, "Testers"sv, ReplaceMode::FirstOnly);
|
||||
EXPECT(test_string == "Well, hello Testers!");
|
||||
|
||||
test_string = test_string.replace("ell", "e're", ReplaceMode::All);
|
||||
test_string = test_string.replace("ell"sv, "e're"sv, ReplaceMode::All);
|
||||
EXPECT(test_string == "We're, he'reo Testers!");
|
||||
|
||||
test_string = test_string.replace("!", " :^)", ReplaceMode::FirstOnly);
|
||||
test_string = test_string.replace("!"sv, " :^)"sv, ReplaceMode::FirstOnly);
|
||||
EXPECT(test_string == "We're, he'reo Testers :^)");
|
||||
|
||||
test_string = String("111._.111._.111");
|
||||
test_string = test_string.replace("111", "|||", ReplaceMode::All);
|
||||
test_string = test_string.replace("111"sv, "|||"sv, ReplaceMode::All);
|
||||
EXPECT(test_string == "|||._.|||._.|||");
|
||||
|
||||
test_string = test_string.replace("|||", "111", ReplaceMode::FirstOnly);
|
||||
test_string = test_string.replace("|||"sv, "111"sv, ReplaceMode::FirstOnly);
|
||||
EXPECT(test_string == "111._.|||._.|||");
|
||||
}
|
||||
|
||||
TEST_CASE(count)
|
||||
{
|
||||
String test_string = "Well, hello Friends!";
|
||||
u32 count = test_string.count("Friends");
|
||||
u32 count = test_string.count("Friends"sv);
|
||||
EXPECT(count == 1);
|
||||
|
||||
count = test_string.count("ell");
|
||||
count = test_string.count("ell"sv);
|
||||
EXPECT(count == 2);
|
||||
|
||||
count = test_string.count("!");
|
||||
count = test_string.count("!"sv);
|
||||
EXPECT(count == 1);
|
||||
|
||||
test_string = String("111._.111._.111");
|
||||
count = test_string.count("111");
|
||||
count = test_string.count("111"sv);
|
||||
EXPECT(count == 3);
|
||||
|
||||
count = test_string.count("._.");
|
||||
count = test_string.count("._."sv);
|
||||
EXPECT(count == 2);
|
||||
}
|
||||
|
||||
|
@ -251,7 +251,7 @@ TEST_CASE(split)
|
|||
TEST_CASE(builder_zero_initial_capacity)
|
||||
{
|
||||
StringBuilder builder(0);
|
||||
builder.append("");
|
||||
builder.append(""sv);
|
||||
auto built = builder.build();
|
||||
EXPECT_EQ(built.is_null(), false);
|
||||
EXPECT_EQ(built.length(), 0u);
|
||||
|
|
|
@ -13,67 +13,67 @@ TEST_CASE(matches_null)
|
|||
{
|
||||
EXPECT(AK::StringUtils::matches(StringView(), StringView()));
|
||||
|
||||
EXPECT(!AK::StringUtils::matches(StringView(), ""));
|
||||
EXPECT(!AK::StringUtils::matches(StringView(), "*"));
|
||||
EXPECT(!AK::StringUtils::matches(StringView(), "?"));
|
||||
EXPECT(!AK::StringUtils::matches(StringView(), "a"));
|
||||
EXPECT(!AK::StringUtils::matches(StringView(), ""sv));
|
||||
EXPECT(!AK::StringUtils::matches(StringView(), "*"sv));
|
||||
EXPECT(!AK::StringUtils::matches(StringView(), "?"sv));
|
||||
EXPECT(!AK::StringUtils::matches(StringView(), "a"sv));
|
||||
|
||||
EXPECT(!AK::StringUtils::matches("", StringView()));
|
||||
EXPECT(!AK::StringUtils::matches("a", StringView()));
|
||||
EXPECT(!AK::StringUtils::matches(""sv, StringView()));
|
||||
EXPECT(!AK::StringUtils::matches("a"sv, StringView()));
|
||||
}
|
||||
|
||||
TEST_CASE(matches_empty)
|
||||
{
|
||||
EXPECT(AK::StringUtils::matches("", ""));
|
||||
EXPECT(AK::StringUtils::matches(""sv, ""sv));
|
||||
|
||||
EXPECT(AK::StringUtils::matches("", "*"));
|
||||
EXPECT(!AK::StringUtils::matches("", "?"));
|
||||
EXPECT(!AK::StringUtils::matches("", "a"));
|
||||
EXPECT(AK::StringUtils::matches(""sv, "*"sv));
|
||||
EXPECT(!AK::StringUtils::matches(""sv, "?"sv));
|
||||
EXPECT(!AK::StringUtils::matches(""sv, "a"sv));
|
||||
|
||||
EXPECT(!AK::StringUtils::matches("a", ""));
|
||||
EXPECT(!AK::StringUtils::matches("a"sv, ""sv));
|
||||
}
|
||||
|
||||
TEST_CASE(matches_case_sensitive)
|
||||
{
|
||||
EXPECT(AK::StringUtils::matches("a", "a", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::matches("a", "A", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::matches("A", "a", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::matches("a"sv, "a"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::matches("a"sv, "A"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::matches("A"sv, "a"sv, CaseSensitivity::CaseSensitive));
|
||||
}
|
||||
|
||||
TEST_CASE(matches_case_insensitive)
|
||||
{
|
||||
EXPECT(!AK::StringUtils::matches("aa", "a"));
|
||||
EXPECT(AK::StringUtils::matches("aa", "*"));
|
||||
EXPECT(!AK::StringUtils::matches("cb", "?a"));
|
||||
EXPECT(AK::StringUtils::matches("adceb", "a*b"));
|
||||
EXPECT(!AK::StringUtils::matches("acdcb", "a*c?b"));
|
||||
EXPECT(!AK::StringUtils::matches("aa"sv, "a"sv));
|
||||
EXPECT(AK::StringUtils::matches("aa"sv, "*"sv));
|
||||
EXPECT(!AK::StringUtils::matches("cb"sv, "?a"sv));
|
||||
EXPECT(AK::StringUtils::matches("adceb"sv, "a*b"sv));
|
||||
EXPECT(!AK::StringUtils::matches("acdcb"sv, "a*c?b"sv));
|
||||
}
|
||||
|
||||
TEST_CASE(matches_with_positions)
|
||||
{
|
||||
Vector<AK::MaskSpan> spans;
|
||||
EXPECT(AK::StringUtils::matches("abbb", "a*", CaseSensitivity::CaseSensitive, &spans));
|
||||
EXPECT(AK::StringUtils::matches("abbb"sv, "a*"sv, CaseSensitivity::CaseSensitive, &spans));
|
||||
EXPECT(spans == Vector<AK::MaskSpan>({ { 1, 3 } }));
|
||||
|
||||
spans.clear();
|
||||
EXPECT(AK::StringUtils::matches("abbb", "?*", CaseSensitivity::CaseSensitive, &spans));
|
||||
EXPECT(AK::StringUtils::matches("abbb"sv, "?*"sv, CaseSensitivity::CaseSensitive, &spans));
|
||||
EXPECT_EQ(spans, Vector<AK::MaskSpan>({ { 0, 1 }, { 1, 3 } }));
|
||||
|
||||
spans.clear();
|
||||
EXPECT(AK::StringUtils::matches("acdcxb", "a*c?b", CaseSensitivity::CaseSensitive, &spans));
|
||||
EXPECT(AK::StringUtils::matches("acdcxb"sv, "a*c?b"sv, CaseSensitivity::CaseSensitive, &spans));
|
||||
EXPECT_EQ(spans, Vector<AK::MaskSpan>({ { 1, 2 }, { 4, 1 } }));
|
||||
|
||||
spans.clear();
|
||||
EXPECT(AK::StringUtils::matches("aaaa", "A*", CaseSensitivity::CaseInsensitive, &spans));
|
||||
EXPECT(AK::StringUtils::matches("aaaa"sv, "A*"sv, CaseSensitivity::CaseInsensitive, &spans));
|
||||
EXPECT_EQ(spans, Vector<AK::MaskSpan>({ { 1, 3 } }));
|
||||
}
|
||||
|
||||
// #4607
|
||||
TEST_CASE(matches_trailing)
|
||||
{
|
||||
EXPECT(AK::StringUtils::matches("ab", "ab*"));
|
||||
EXPECT(AK::StringUtils::matches("ab", "ab****"));
|
||||
EXPECT(AK::StringUtils::matches("ab", "*ab****"));
|
||||
EXPECT(AK::StringUtils::matches("ab"sv, "ab*"sv));
|
||||
EXPECT(AK::StringUtils::matches("ab"sv, "ab****"sv));
|
||||
EXPECT(AK::StringUtils::matches("ab"sv, "*ab****"sv));
|
||||
}
|
||||
|
||||
TEST_CASE(convert_to_int)
|
||||
|
@ -81,76 +81,76 @@ TEST_CASE(convert_to_int)
|
|||
auto value = AK::StringUtils::convert_to_int(StringView());
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_int("");
|
||||
value = AK::StringUtils::convert_to_int(""sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_int("a");
|
||||
value = AK::StringUtils::convert_to_int("a"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_int("+");
|
||||
value = AK::StringUtils::convert_to_int("+"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_int("-");
|
||||
value = AK::StringUtils::convert_to_int("-"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
auto actual = AK::StringUtils::convert_to_int("0");
|
||||
auto actual = AK::StringUtils::convert_to_int("0"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 0);
|
||||
|
||||
actual = AK::StringUtils::convert_to_int("1");
|
||||
actual = AK::StringUtils::convert_to_int("1"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 1);
|
||||
|
||||
actual = AK::StringUtils::convert_to_int("+1");
|
||||
actual = AK::StringUtils::convert_to_int("+1"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 1);
|
||||
|
||||
actual = AK::StringUtils::convert_to_int("-1");
|
||||
actual = AK::StringUtils::convert_to_int("-1"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), -1);
|
||||
|
||||
actual = AK::StringUtils::convert_to_int("01");
|
||||
actual = AK::StringUtils::convert_to_int("01"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 1);
|
||||
|
||||
actual = AK::StringUtils::convert_to_int("12345");
|
||||
actual = AK::StringUtils::convert_to_int("12345"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 12345);
|
||||
|
||||
actual = AK::StringUtils::convert_to_int("-12345");
|
||||
actual = AK::StringUtils::convert_to_int("-12345"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), -12345);
|
||||
|
||||
actual = AK::StringUtils::convert_to_int(" \t-12345 \n\n");
|
||||
actual = AK::StringUtils::convert_to_int(" \t-12345 \n\n"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), -12345);
|
||||
|
||||
auto actual_i8 = AK::StringUtils::convert_to_int<i8>("-1");
|
||||
auto actual_i8 = AK::StringUtils::convert_to_int<i8>("-1"sv);
|
||||
EXPECT(actual_i8.has_value());
|
||||
EXPECT_EQ(actual_i8.value(), -1);
|
||||
EXPECT_EQ(sizeof(actual_i8.value()), (size_t)1);
|
||||
actual_i8 = AK::StringUtils::convert_to_int<i8>("128");
|
||||
actual_i8 = AK::StringUtils::convert_to_int<i8>("128"sv);
|
||||
EXPECT(!actual_i8.has_value());
|
||||
|
||||
auto actual_i16 = AK::StringUtils::convert_to_int<i16>("-1");
|
||||
auto actual_i16 = AK::StringUtils::convert_to_int<i16>("-1"sv);
|
||||
EXPECT(actual_i16.has_value());
|
||||
EXPECT_EQ(actual_i16.value(), -1);
|
||||
EXPECT_EQ(sizeof(actual_i16.value()), (size_t)2);
|
||||
actual_i16 = AK::StringUtils::convert_to_int<i16>("32768");
|
||||
actual_i16 = AK::StringUtils::convert_to_int<i16>("32768"sv);
|
||||
EXPECT(!actual_i16.has_value());
|
||||
|
||||
auto actual_i32 = AK::StringUtils::convert_to_int<i32>("-1");
|
||||
auto actual_i32 = AK::StringUtils::convert_to_int<i32>("-1"sv);
|
||||
EXPECT(actual_i32.has_value());
|
||||
EXPECT_EQ(actual_i32.value(), -1);
|
||||
EXPECT_EQ(sizeof(actual_i32.value()), (size_t)4);
|
||||
actual_i32 = AK::StringUtils::convert_to_int<i32>("2147483648");
|
||||
actual_i32 = AK::StringUtils::convert_to_int<i32>("2147483648"sv);
|
||||
EXPECT(!actual_i32.has_value());
|
||||
|
||||
auto actual_i64 = AK::StringUtils::convert_to_int<i64>("-1");
|
||||
auto actual_i64 = AK::StringUtils::convert_to_int<i64>("-1"sv);
|
||||
EXPECT(actual_i64.has_value());
|
||||
EXPECT_EQ(actual_i64.value(), -1);
|
||||
EXPECT_EQ(sizeof(actual_i64.value()), (size_t)8);
|
||||
actual_i64 = AK::StringUtils::convert_to_int<i64>("9223372036854775808");
|
||||
actual_i64 = AK::StringUtils::convert_to_int<i64>("9223372036854775808"sv);
|
||||
EXPECT(!actual_i64.has_value());
|
||||
}
|
||||
|
||||
|
@ -159,70 +159,70 @@ TEST_CASE(convert_to_uint)
|
|||
auto value = AK::StringUtils::convert_to_uint(StringView());
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint("");
|
||||
value = AK::StringUtils::convert_to_uint(""sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint("a");
|
||||
value = AK::StringUtils::convert_to_uint("a"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint("+");
|
||||
value = AK::StringUtils::convert_to_uint("+"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint("-");
|
||||
value = AK::StringUtils::convert_to_uint("-"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint("+1");
|
||||
value = AK::StringUtils::convert_to_uint("+1"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint("-1");
|
||||
value = AK::StringUtils::convert_to_uint("-1"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
auto actual = AK::StringUtils::convert_to_uint("0");
|
||||
auto actual = AK::StringUtils::convert_to_uint("0"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 0u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint("1");
|
||||
actual = AK::StringUtils::convert_to_uint("1"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 1u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint("01");
|
||||
actual = AK::StringUtils::convert_to_uint("01"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 1u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint("12345");
|
||||
actual = AK::StringUtils::convert_to_uint("12345"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 12345u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint(" \t12345 \n\n");
|
||||
actual = AK::StringUtils::convert_to_uint(" \t12345 \n\n"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 12345u);
|
||||
|
||||
auto actual_u8 = AK::StringUtils::convert_to_uint<u8>("255");
|
||||
auto actual_u8 = AK::StringUtils::convert_to_uint<u8>("255"sv);
|
||||
EXPECT(actual_u8.has_value());
|
||||
EXPECT_EQ(actual_u8.value(), 255u);
|
||||
EXPECT_EQ(sizeof(actual_u8.value()), (size_t)1);
|
||||
actual_u8 = AK::StringUtils::convert_to_uint<u8>("256");
|
||||
actual_u8 = AK::StringUtils::convert_to_uint<u8>("256"sv);
|
||||
EXPECT(!actual_u8.has_value());
|
||||
|
||||
auto actual_u16 = AK::StringUtils::convert_to_uint<u16>("65535");
|
||||
auto actual_u16 = AK::StringUtils::convert_to_uint<u16>("65535"sv);
|
||||
EXPECT(actual_u16.has_value());
|
||||
EXPECT_EQ(actual_u16.value(), 65535u);
|
||||
EXPECT_EQ(sizeof(actual_u16.value()), (size_t)2);
|
||||
actual_u16 = AK::StringUtils::convert_to_uint<u16>("65536");
|
||||
actual_u16 = AK::StringUtils::convert_to_uint<u16>("65536"sv);
|
||||
EXPECT(!actual_u16.has_value());
|
||||
|
||||
auto actual_u32 = AK::StringUtils::convert_to_uint<u32>("4294967295");
|
||||
auto actual_u32 = AK::StringUtils::convert_to_uint<u32>("4294967295"sv);
|
||||
EXPECT(actual_u32.has_value());
|
||||
EXPECT_EQ(actual_u32.value(), 4294967295ul);
|
||||
EXPECT_EQ(sizeof(actual_u32.value()), (size_t)4);
|
||||
actual_u32 = AK::StringUtils::convert_to_uint<u32>("4294967296");
|
||||
actual_u32 = AK::StringUtils::convert_to_uint<u32>("4294967296"sv);
|
||||
EXPECT(!actual_u32.has_value());
|
||||
|
||||
auto actual_u64 = AK::StringUtils::convert_to_uint<u64>("18446744073709551615");
|
||||
auto actual_u64 = AK::StringUtils::convert_to_uint<u64>("18446744073709551615"sv);
|
||||
EXPECT(actual_u64.has_value());
|
||||
EXPECT_EQ(actual_u64.value(), 18446744073709551615ull);
|
||||
EXPECT_EQ(sizeof(actual_u64.value()), (size_t)8);
|
||||
actual_u64 = AK::StringUtils::convert_to_uint<u64>("18446744073709551616");
|
||||
actual_u64 = AK::StringUtils::convert_to_uint<u64>("18446744073709551616"sv);
|
||||
EXPECT(!actual_u64.has_value());
|
||||
}
|
||||
|
||||
|
@ -231,51 +231,51 @@ TEST_CASE(convert_to_uint_from_octal)
|
|||
auto value = AK::StringUtils::convert_to_uint_from_octal<u16>(StringView());
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("");
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>(""sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("a");
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("a"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("+");
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("+"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("-");
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("-"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("+1");
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("+1"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("-1");
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("-1"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("8");
|
||||
value = AK::StringUtils::convert_to_uint_from_octal<u16>("8"sv);
|
||||
EXPECT(!value.has_value());
|
||||
|
||||
auto actual = AK::StringUtils::convert_to_uint_from_octal<u16>("77777777");
|
||||
auto actual = AK::StringUtils::convert_to_uint_from_octal<u16>("77777777"sv);
|
||||
EXPECT(!actual.has_value());
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("0");
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("0"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 0u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("1");
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("1"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 1u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("0755");
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("0755"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 0755u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("755");
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("755"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 0755u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>(" \t644 \n\n");
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>(" \t644 \n\n"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 0644u);
|
||||
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("177777");
|
||||
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("177777"sv);
|
||||
EXPECT_EQ(actual.has_value(), true);
|
||||
EXPECT_EQ(actual.value(), 0177777u);
|
||||
}
|
||||
|
@ -283,85 +283,85 @@ TEST_CASE(convert_to_uint_from_octal)
|
|||
TEST_CASE(ends_with)
|
||||
{
|
||||
String test_string = "ABCDEF";
|
||||
EXPECT(AK::StringUtils::ends_with(test_string, "DEF", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::ends_with(test_string, "ABCDEF", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::ends_with(test_string, "ABCDE", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::ends_with(test_string, "ABCDEFG", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::ends_with(test_string, "def", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::ends_with(test_string, "def", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::ends_with(test_string, "DEF"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::ends_with(test_string, "ABCDEF"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::ends_with(test_string, "ABCDE"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::ends_with(test_string, "ABCDEFG"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::ends_with(test_string, "def"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::ends_with(test_string, "def"sv, CaseSensitivity::CaseSensitive));
|
||||
}
|
||||
|
||||
TEST_CASE(starts_with)
|
||||
{
|
||||
String test_string = "ABCDEF";
|
||||
EXPECT(AK::StringUtils::starts_with(test_string, "ABC", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::starts_with(test_string, "ABCDEF", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::starts_with(test_string, "BCDEF", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::starts_with(test_string, "ABCDEFG", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::starts_with(test_string, "abc", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::starts_with(test_string, "abc", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::starts_with(test_string, "ABC"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::starts_with(test_string, "ABCDEF"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::starts_with(test_string, "BCDEF"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::starts_with(test_string, "ABCDEFG"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::starts_with(test_string, "abc"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::starts_with(test_string, "abc"sv, CaseSensitivity::CaseSensitive));
|
||||
}
|
||||
|
||||
TEST_CASE(contains)
|
||||
{
|
||||
String test_string = "ABCDEFABCXYZ";
|
||||
EXPECT(AK::StringUtils::contains(test_string, "ABC", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "ABC", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "AbC", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "BCX", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "BCX", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "BcX", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "xyz", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "xyz", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "EFG", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "EfG", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::contains("", test_string, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::contains("", test_string, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "L", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "L", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "ABC"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "ABC"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "AbC"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "BCX"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "BCX"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "BcX"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "xyz"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, "xyz"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "EFG"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "EfG"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, ""sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(test_string, ""sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::contains(""sv, test_string, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::contains(""sv, test_string, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "L"sv, CaseSensitivity::CaseSensitive));
|
||||
EXPECT(!AK::StringUtils::contains(test_string, "L"sv, CaseSensitivity::CaseInsensitive));
|
||||
|
||||
String command_palette_bug_string = "Go Go Back";
|
||||
EXPECT(AK::StringUtils::contains(command_palette_bug_string, "Go Back", AK::CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(command_palette_bug_string, "gO bAcK", AK::CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(AK::StringUtils::contains(command_palette_bug_string, "Go Back"sv, AK::CaseSensitivity::CaseSensitive));
|
||||
EXPECT(AK::StringUtils::contains(command_palette_bug_string, "gO bAcK"sv, AK::CaseSensitivity::CaseInsensitive));
|
||||
}
|
||||
|
||||
TEST_CASE(is_whitespace)
|
||||
{
|
||||
EXPECT(AK::StringUtils::is_whitespace(""));
|
||||
EXPECT(AK::StringUtils::is_whitespace(" "));
|
||||
EXPECT(AK::StringUtils::is_whitespace(" \t"));
|
||||
EXPECT(AK::StringUtils::is_whitespace(" \t\n"));
|
||||
EXPECT(AK::StringUtils::is_whitespace(" \t\n\r\v"));
|
||||
EXPECT(!AK::StringUtils::is_whitespace(" a "));
|
||||
EXPECT(!AK::StringUtils::is_whitespace("a\t"));
|
||||
EXPECT(AK::StringUtils::is_whitespace(""sv));
|
||||
EXPECT(AK::StringUtils::is_whitespace(" "sv));
|
||||
EXPECT(AK::StringUtils::is_whitespace(" \t"sv));
|
||||
EXPECT(AK::StringUtils::is_whitespace(" \t\n"sv));
|
||||
EXPECT(AK::StringUtils::is_whitespace(" \t\n\r\v"sv));
|
||||
EXPECT(!AK::StringUtils::is_whitespace(" a "sv));
|
||||
EXPECT(!AK::StringUtils::is_whitespace("a\t"sv));
|
||||
}
|
||||
|
||||
TEST_CASE(find)
|
||||
{
|
||||
String test_string = "1234567";
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "1").value_or(1), 0u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "2").value_or(2), 1u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "3").value_or(3), 2u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "4").value_or(4), 3u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "5").value_or(5), 4u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "34").value_or(3), 2u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "78").has_value(), false);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "1"sv).value_or(1), 0u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "2"sv).value_or(2), 1u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "3"sv).value_or(3), 2u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "4"sv).value_or(4), 3u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "5"sv).value_or(5), 4u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "34"sv).value_or(3), 2u);
|
||||
EXPECT_EQ(AK::StringUtils::find(test_string, "78"sv).has_value(), false);
|
||||
}
|
||||
|
||||
TEST_CASE(to_snakecase)
|
||||
{
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("foobar"), "foobar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("Foobar"), "foobar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FOOBAR"), "foobar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("fooBar"), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FooBar"), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("fooBAR"), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FOOBar"), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("foo_bar"), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FBar"), "f_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FooB"), "foo_b");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("foobar"sv), "foobar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("Foobar"sv), "foobar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FOOBAR"sv), "foobar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("fooBar"sv), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FooBar"sv), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("fooBAR"sv), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FOOBar"sv), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("foo_bar"sv), "foo_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FBar"sv), "f_bar");
|
||||
EXPECT_EQ(AK::StringUtils::to_snakecase("FooB"sv), "foo_b");
|
||||
}
|
||||
|
||||
TEST_CASE(to_titlecase)
|
||||
|
|
|
@ -55,25 +55,25 @@ TEST_CASE(starts_with)
|
|||
StringView test_string_view = test_string.view();
|
||||
EXPECT(test_string_view.starts_with('A'));
|
||||
EXPECT(!test_string_view.starts_with('B'));
|
||||
EXPECT(test_string_view.starts_with("AB"));
|
||||
EXPECT(test_string_view.starts_with("ABCDEF"));
|
||||
EXPECT(!test_string_view.starts_with("DEF"));
|
||||
EXPECT(test_string_view.starts_with("abc", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!test_string_view.starts_with("abc", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(test_string_view.starts_with("AB"sv));
|
||||
EXPECT(test_string_view.starts_with("ABCDEF"sv));
|
||||
EXPECT(!test_string_view.starts_with("DEF"sv));
|
||||
EXPECT(test_string_view.starts_with("abc"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!test_string_view.starts_with("abc"sv, CaseSensitivity::CaseSensitive));
|
||||
}
|
||||
|
||||
TEST_CASE(ends_with)
|
||||
{
|
||||
String test_string = "ABCDEF";
|
||||
StringView test_string_view = test_string.view();
|
||||
EXPECT(test_string_view.ends_with("DEF"));
|
||||
EXPECT(test_string_view.ends_with("DEF"sv));
|
||||
EXPECT(test_string_view.ends_with('F'));
|
||||
EXPECT(!test_string_view.ends_with('E'));
|
||||
EXPECT(test_string_view.ends_with("ABCDEF"));
|
||||
EXPECT(!test_string_view.ends_with("ABCDE"));
|
||||
EXPECT(!test_string_view.ends_with("ABCDEFG"));
|
||||
EXPECT(test_string_view.ends_with("def", CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!test_string_view.ends_with("def", CaseSensitivity::CaseSensitive));
|
||||
EXPECT(test_string_view.ends_with("ABCDEF"sv));
|
||||
EXPECT(!test_string_view.ends_with("ABCDE"sv));
|
||||
EXPECT(!test_string_view.ends_with("ABCDEFG"sv));
|
||||
EXPECT(test_string_view.ends_with("def"sv, CaseSensitivity::CaseInsensitive));
|
||||
EXPECT(!test_string_view.ends_with("def"sv, CaseSensitivity::CaseSensitive));
|
||||
}
|
||||
|
||||
TEST_CASE(lines)
|
||||
|
@ -127,42 +127,42 @@ TEST_CASE(find_last)
|
|||
TEST_CASE(find_any_of)
|
||||
{
|
||||
auto test_string_view = "aabbcc_xy_ccbbaa"sv;
|
||||
EXPECT_EQ(test_string_view.find_any_of("bc", StringView::SearchDirection::Forward), 2U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("yx", StringView::SearchDirection::Forward), 7U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("defg", StringView::SearchDirection::Forward).has_value(), false);
|
||||
EXPECT_EQ(test_string_view.find_any_of("bc", StringView::SearchDirection::Backward), 13U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("yx", StringView::SearchDirection::Backward), 8U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("fghi", StringView::SearchDirection::Backward).has_value(), false);
|
||||
EXPECT_EQ(test_string_view.find_any_of("bc"sv, StringView::SearchDirection::Forward), 2U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("yx"sv, StringView::SearchDirection::Forward), 7U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("defg"sv, StringView::SearchDirection::Forward).has_value(), false);
|
||||
EXPECT_EQ(test_string_view.find_any_of("bc"sv, StringView::SearchDirection::Backward), 13U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("yx"sv, StringView::SearchDirection::Backward), 8U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("fghi"sv, StringView::SearchDirection::Backward).has_value(), false);
|
||||
|
||||
test_string_view = "/"sv;
|
||||
EXPECT_EQ(test_string_view.find_any_of("/", StringView::SearchDirection::Forward), 0U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("/", StringView::SearchDirection::Backward), 0U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("/"sv, StringView::SearchDirection::Forward), 0U);
|
||||
EXPECT_EQ(test_string_view.find_any_of("/"sv, StringView::SearchDirection::Backward), 0U);
|
||||
}
|
||||
|
||||
TEST_CASE(split_view)
|
||||
{
|
||||
StringView test_string_view = "axxbxcxd";
|
||||
EXPECT_EQ(test_string_view.split_view('x'), Vector<StringView>({ "a", "b", "c", "d" }));
|
||||
EXPECT_EQ(test_string_view.split_view('x', true), Vector<StringView>({ "a", "", "b", "c", "d" }));
|
||||
EXPECT_EQ(test_string_view.split_view("x"), Vector<StringView>({ "a", "b", "c", "d" }));
|
||||
EXPECT_EQ(test_string_view.split_view("x", true), Vector<StringView>({ "a", "", "b", "c", "d" }));
|
||||
StringView test_string_view = "axxbxcxd"sv;
|
||||
EXPECT_EQ(test_string_view.split_view('x'), Vector({ "a"sv, "b"sv, "c"sv, "d"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view('x', true), Vector({ "a"sv, ""sv, "b"sv, "c"sv, "d"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view("x"sv), Vector({ "a"sv, "b"sv, "c"sv, "d"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view("x"sv, true), Vector({ "a"sv, ""sv, "b"sv, "c"sv, "d"sv }));
|
||||
|
||||
test_string_view = "axxbx";
|
||||
EXPECT_EQ(test_string_view.split_view('x'), Vector<StringView>({ "a", "b" }));
|
||||
EXPECT_EQ(test_string_view.split_view('x', true), Vector<StringView>({ "a", "", "b", "" }));
|
||||
EXPECT_EQ(test_string_view.split_view("x"), Vector<StringView>({ "a", "b" }));
|
||||
EXPECT_EQ(test_string_view.split_view("x", true), Vector<StringView>({ "a", "", "b", "" }));
|
||||
test_string_view = "axxbx"sv;
|
||||
EXPECT_EQ(test_string_view.split_view('x'), Vector({ "a"sv, "b"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view('x', true), Vector({ "a"sv, ""sv, "b"sv, ""sv }));
|
||||
EXPECT_EQ(test_string_view.split_view("x"sv), Vector({ "a"sv, "b"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view("x"sv, true), Vector({ "a"sv, ""sv, "b"sv, ""sv }));
|
||||
|
||||
test_string_view = "axxbcxxdxx";
|
||||
EXPECT_EQ(test_string_view.split_view("xx"), Vector<StringView>({ "a", "bc", "d" }));
|
||||
EXPECT_EQ(test_string_view.split_view("xx", true), Vector<StringView>({ "a", "bc", "d", "" }));
|
||||
test_string_view = "axxbcxxdxx"sv;
|
||||
EXPECT_EQ(test_string_view.split_view("xx"sv), Vector({ "a"sv, "bc"sv, "d"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view("xx"sv, true), Vector({ "a"sv, "bc"sv, "d"sv, ""sv }));
|
||||
|
||||
test_string_view = "ax_b_cxd";
|
||||
test_string_view = "ax_b_cxd"sv;
|
||||
Function<bool(char)> predicate = [](char ch) { return ch == 'x' || ch == '_'; };
|
||||
EXPECT_EQ(test_string_view.split_view_if(predicate), Vector<StringView>({ "a", "b", "c", "d" }));
|
||||
EXPECT_EQ(test_string_view.split_view_if(predicate, true), Vector<StringView>({ "a", "", "b", "c", "d" }));
|
||||
EXPECT_EQ(test_string_view.split_view_if(predicate), Vector<StringView>({ "a", "b", "c", "d" }));
|
||||
EXPECT_EQ(test_string_view.split_view_if(predicate, true), Vector<StringView>({ "a", "", "b", "c", "d" }));
|
||||
EXPECT_EQ(test_string_view.split_view_if(predicate), Vector({ "a"sv, "b"sv, "c"sv, "d"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view_if(predicate, true), Vector({ "a"sv, ""sv, "b"sv, "c"sv, "d"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view_if(predicate), Vector({ "a"sv, "b"sv, "c"sv, "d"sv }));
|
||||
EXPECT_EQ(test_string_view.split_view_if(predicate, true), Vector({ "a"sv, ""sv, "b"sv, "c"sv, "d"sv }));
|
||||
}
|
||||
|
||||
TEST_CASE(constexpr_stuff)
|
||||
|
|
|
@ -12,7 +12,7 @@
|
|||
TEST_CASE(normal_behavior)
|
||||
{
|
||||
Trie<char, String> dictionary('/', "");
|
||||
constexpr StringView data[] { "test", "example", "foo", "foobar" };
|
||||
constexpr StringView data[] { "test"sv, "example"sv, "foo"sv, "foobar"sv };
|
||||
constexpr size_t total_chars = 18; // root (1), 'test' (4), 'example' (7), 'foo' (3), 'foobar' (3, "foo" already stored).
|
||||
for (auto& view : data) {
|
||||
auto it = view.begin();
|
||||
|
@ -33,7 +33,7 @@ TEST_CASE(normal_behavior)
|
|||
EXPECT_EQ(view, node.metadata_value());
|
||||
}
|
||||
|
||||
constexpr StringView test_data_with_prefix_in_dict[] { "testx", "exampley", "fooa", "foobarb", "fox", "text" };
|
||||
constexpr StringView test_data_with_prefix_in_dict[] { "testx"sv, "exampley"sv, "fooa"sv, "foobarb"sv, "fox"sv, "text"sv };
|
||||
for (auto& view : test_data_with_prefix_in_dict) {
|
||||
auto it = view.begin();
|
||||
auto& node = dictionary.traverse_until_last_accessible_node(it, view.end());
|
||||
|
|
|
@ -316,7 +316,7 @@ TEST_CASE(port_overflow)
|
|||
|
||||
TEST_CASE(equality)
|
||||
{
|
||||
EXPECT(URL("http://serenityos.org").equals("http://serenityos.org#test", URL::ExcludeFragment::Yes));
|
||||
EXPECT(URL("http://serenityos.org").equals("http://serenityos.org#test"sv, URL::ExcludeFragment::Yes));
|
||||
EXPECT_EQ(URL("http://example.com/index.html"), URL("http://ex%61mple.com/index.html"));
|
||||
EXPECT_EQ(URL("file:///my/file"), URL("file://localhost/my/file"));
|
||||
EXPECT_NE(URL("http://serenityos.org/index.html"), URL("http://serenityos.org/test.html"));
|
||||
|
|
|
@ -65,8 +65,8 @@ TEST_CASE(strings_insert_ordered)
|
|||
strings.append("def");
|
||||
strings.append("ghi");
|
||||
|
||||
strings.insert_before_matching("f-g", [](auto& entry) {
|
||||
return "f-g" < entry;
|
||||
strings.insert_before_matching("f-g"sv, [](auto& entry) {
|
||||
return "f-g"sv < entry;
|
||||
});
|
||||
|
||||
EXPECT_EQ(strings[0], "abc");
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue