RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-28 15:47:34 +00:00
Code Issues Activity Actions

Everywhere: Add sv suffix to strings relying on StringView(char const*)

Browse source 
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:
sin-ack 2022-07-11 17:32:29 +00:00 • committed by Andreas Kling
parent e5f09ea170
commit 3f3f45580a
762 changed files with 8315 additions and 8316 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Tests/AK/TestFormat.cpp
View file

@ -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);
}
};

12
Tests/AK/TestIPv4Address.cpp
View file

@ -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]);

16
Tests/AK/TestJSON.cpp
View file

@ -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);
}

44
Tests/AK/TestLexicalPath.cpp
View file

@ -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");
}

8
Tests/AK/TestMACAddress.cpp
View file

@ -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());
}

18
Tests/AK/TestOptional.cpp
View file

@ -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);

60
Tests/AK/TestString.cpp
View file

@ -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);

266
Tests/AK/TestStringUtils.cpp
View file

@ -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)

74
Tests/AK/TestStringView.cpp
View file

@ -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)

4
Tests/AK/TestTrie.cpp
View file

@ -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());

2
Tests/AK/TestURL.cpp
View file

@ -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"));

4
Tests/AK/TestVector.cpp
View file

@ -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");