RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-28 02:07:35 +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");

2
Tests/Kernel/fuzz-syscalls.cpp
View file

@ -97,7 +97,7 @@ static void do_weird_call(size_t attempt, int syscall_fn, size_t arg1, size_t ar
attempt, Syscall::to_string((Syscall::Function)syscall_fn), arg1, arg2, arg3, fake_params);
for (size_t i = 0; i < fake_params_count; ++i) {
if (i != 0)
builder.append(", ");
builder.append(", "sv);
builder.appendff("{:p}", fake_params[i]);
}
builder.append("]");

18
Tests/LibCompress/TestBrotli.cpp
View file

@ -32,47 +32,47 @@ static void run_test(StringView const file_name)
TEST_CASE(brotli_decompress_uncompressed)
{
run_test("wellhello.txt");
run_test("wellhello.txt"sv);
}
TEST_CASE(brotli_decompress_simple)
{
run_test("hello.txt");
run_test("hello.txt"sv);
}
TEST_CASE(brotli_decompress_simple2)
{
run_test("wellhello2.txt");
run_test("wellhello2.txt"sv);
}
TEST_CASE(brotli_decompress_lorem)
{
run_test("lorem.txt");
run_test("lorem.txt"sv);
}
TEST_CASE(brotli_decompress_lorem2)
{
run_test("lorem2.txt");
run_test("lorem2.txt"sv);
}
TEST_CASE(brotli_decompress_transform)
{
run_test("transform.txt");
run_test("transform.txt"sv);
}
TEST_CASE(brotli_decompress_serenityos_html)
{
run_test("serenityos.html");
run_test("serenityos.html"sv);
}
TEST_CASE(brotli_decompress_happy3rd_html)
{
run_test("happy3rd.html");
run_test("happy3rd.html"sv);
}
TEST_CASE(brotli_decompress_katica_regular_10_font)
{
run_test("KaticaRegular10.font");
run_test("KaticaRegular10.font"sv);
}
TEST_CASE(brotli_decompress_zero_one_bin)

12
Tests/LibCore/TestLibCoreFilePermissionsMask.cpp
View file

@ -74,19 +74,19 @@ TEST_CASE(file_permission_mask_from_symbolic_notation)
mask = Core::FilePermissionsMask::from_symbolic_notation("z+rw"sv);
EXPECT(mask.is_error());
EXPECT(mask.error().string_literal().starts_with("invalid class"));
EXPECT(mask.error().string_literal().starts_with("invalid class"sv));
mask = Core::FilePermissionsMask::from_symbolic_notation("u*rw"sv);
EXPECT(mask.is_error());
EXPECT(mask.error().string_literal().starts_with("invalid operation"));
EXPECT(mask.error().string_literal().starts_with("invalid operation"sv));
mask = Core::FilePermissionsMask::from_symbolic_notation("u+rz"sv);
EXPECT(mask.is_error());
EXPECT(mask.error().string_literal().starts_with("invalid symbolic permission"));
EXPECT(mask.error().string_literal().starts_with("invalid symbolic permission"sv));
mask = Core::FilePermissionsMask::from_symbolic_notation("u+rw;g+rw"sv);
EXPECT(mask.is_error());
EXPECT(mask.error().string_literal().starts_with("invalid symbolic permission"));
EXPECT(mask.error().string_literal().starts_with("invalid symbolic permission"sv));
}
TEST_CASE(file_permission_mask_parse)
@ -100,9 +100,9 @@ TEST_CASE(file_permission_mask_parse)
EXPECT_EQ(numeric_mask.value().clear_mask(), symbolic_mask.value().clear_mask());
EXPECT_EQ(numeric_mask.value().write_mask(), symbolic_mask.value().write_mask());
auto mask = Core::FilePermissionsMask::parse("888");
auto mask = Core::FilePermissionsMask::parse("888"sv);
EXPECT(mask.is_error());
mask = Core::FilePermissionsMask::parse("z+rw");
mask = Core::FilePermissionsMask::parse("z+rw"sv);
EXPECT(mask.is_error());
}

4
Tests/LibCore/TestLibCoreIODevice.cpp
View file

@ -30,7 +30,7 @@ TEST_CASE(file_readline)
auto outputfile = outfile_or_error.release_value();
while (file->can_read_line()) {
outputfile->write(file->read_line());
outputfile->write("\n");
outputfile->write("\n"sv);
}
file->close();
outputfile->close();
@ -84,7 +84,7 @@ TEST_CASE(file_lines_range)
auto outputfile = outfile_or_error.release_value();
for (auto line : file->lines()) {
outputfile->write(line);
outputfile->write("\n");
outputfile->write("\n"sv);
}
file->close();
outputfile->close();

14
Tests/LibCore/TestLibCoreStream.cpp
View file

@ -20,7 +20,7 @@
TEST_CASE(file_open)
{
auto maybe_file = Core::Stream::File::open("/tmp/file-open-test.txt", Core::Stream::OpenMode::Write);
auto maybe_file = Core::Stream::File::open("/tmp/file-open-test.txt"sv, Core::Stream::OpenMode::Write);
if (maybe_file.is_error()) {
warnln("Failed to open the file: {}", strerror(maybe_file.error().code()));
VERIFY_NOT_REACHED();
@ -40,7 +40,7 @@ TEST_CASE(file_open)
TEST_CASE(file_write_bytes)
{
auto maybe_file = Core::Stream::File::open("/tmp/file-write-bytes-test.txt", Core::Stream::OpenMode::Write);
auto maybe_file = Core::Stream::File::open("/tmp/file-write-bytes-test.txt"sv, Core::Stream::OpenMode::Write);
auto file = maybe_file.release_value();
constexpr auto some_words = "These are some words"sv;
@ -53,7 +53,7 @@ constexpr auto expected_buffer_contents = "&lt;small&gt;(Please consider transla
TEST_CASE(file_read_bytes)
{
auto maybe_file = Core::Stream::File::open("/usr/Tests/LibCore/long_lines.txt", Core::Stream::OpenMode::Read);
auto maybe_file = Core::Stream::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::Stream::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto file = maybe_file.release_value();
@ -75,7 +75,7 @@ constexpr auto expected_seek_contents3 = "levels of advanc"sv;
TEST_CASE(file_seeking_around)
{
auto maybe_file = Core::Stream::File::open("/usr/Tests/LibCore/long_lines.txt", Core::Stream::OpenMode::Read);
auto maybe_file = Core::Stream::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::Stream::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto file = maybe_file.release_value();
@ -137,7 +137,7 @@ TEST_CASE(file_adopt_invalid_fd)
TEST_CASE(file_truncate)
{
auto maybe_file = Core::Stream::File::open("/tmp/file-truncate-test.txt", Core::Stream::OpenMode::Write);
auto maybe_file = Core::Stream::File::open("/tmp/file-truncate-test.txt"sv, Core::Stream::OpenMode::Write);
auto file = maybe_file.release_value();
EXPECT(!file->truncate(999).is_error());
@ -417,7 +417,7 @@ TEST_CASE(local_socket_write)
TEST_CASE(buffered_long_file_read)
{
auto maybe_file = Core::Stream::File::open("/usr/Tests/LibCore/long_lines.txt", Core::Stream::OpenMode::Read);
auto maybe_file = Core::Stream::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::Stream::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto maybe_buffered_file = Core::Stream::BufferedFile::create(maybe_file.release_value());
EXPECT(!maybe_buffered_file.is_error());
@ -439,7 +439,7 @@ TEST_CASE(buffered_long_file_read)
TEST_CASE(buffered_small_file_read)
{
auto maybe_file = Core::Stream::File::open("/usr/Tests/LibCore/small.txt", Core::Stream::OpenMode::Read);
auto maybe_file = Core::Stream::File::open("/usr/Tests/LibCore/small.txt"sv, Core::Stream::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto maybe_buffered_file = Core::Stream::BufferedFile::create(maybe_file.release_value());
EXPECT(!maybe_buffered_file.is_error());

2
Tests/LibCpp/test-cpp-parser.cpp
View file

@ -31,7 +31,7 @@ TEST_CASE(test_regression)
auto file_path = directory_iterator.next_full_path();
auto path = LexicalPath { file_path };
if (!path.has_extension(".cpp"))
if (!path.has_extension(".cpp"sv))
continue;
outln("Checking {}...", path.basename());

2
Tests/LibCpp/test-cpp-preprocessor.cpp
View file

@ -30,7 +30,7 @@ TEST_CASE(test_regression)
auto file_path = directory_iterator.next_full_path();
auto path = LexicalPath { file_path };
if (!path.has_extension(".cpp"))
if (!path.has_extension(".cpp"sv))
continue;
outln("Checking {}...", path.basename());

4
Tests/LibCrypto/TestBigInteger.cpp
View file

@ -234,7 +234,7 @@ TEST_CASE(test_unsigned_bigint_division_combined_test)
TEST_CASE(test_unsigned_bigint_base10_from_string)
{
auto result = Crypto::UnsignedBigInteger::from_base(10, "57195071295721390579057195715793");
auto result = Crypto::UnsignedBigInteger::from_base(10, "57195071295721390579057195715793"sv);
Vector<u32> expected_result { 3806301393, 954919431, 3879607298, 721 };
EXPECT_EQ(result.words(), expected_result);
}
@ -414,7 +414,7 @@ TEST_CASE(test_bigint_import_big_endian_encode_decode_roundtrip)
TEST_CASE(test_bigint_big_endian_import)
{
auto number = Crypto::UnsignedBigInteger::import_data("hello");
auto number = Crypto::UnsignedBigInteger::import_data("hello"sv);
EXPECT_EQ(number, "448378203247"_bigint);
}

52
Tests/LibCrypto/TestHMAC.cpp
View file

@ -13,34 +13,34 @@
TEST_CASE(test_hmac_md5_name)
{
Crypto::Authentication::HMAC<Crypto::Hash::MD5> hmac("Well Hello Friends");
EXPECT_EQ(hmac.class_name(), "HMAC-MD5");
Crypto::Authentication::HMAC<Crypto::Hash::MD5> hmac("Well Hello Friends"sv);
EXPECT_EQ(hmac.class_name(), "HMAC-MD5"sv);
}
TEST_CASE(test_hmac_md5_process)
{
Crypto::Authentication::HMAC<Crypto::Hash::MD5> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::MD5> hmac("Well Hello Friends"sv);
u8 result[] {
0x3b, 0x5b, 0xde, 0x30, 0x3a, 0x54, 0x7b, 0xbb, 0x09, 0xfe, 0x78, 0x89, 0xbc, 0x9f, 0x22, 0xa3
};
auto mac = hmac.process("Some bogus data");
auto mac = hmac.process("Some bogus data"sv);
EXPECT(memcmp(result, mac.data, hmac.digest_size()) == 0);
}
TEST_CASE(test_hmac_md5_process_reuse)
{
Crypto::Authentication::HMAC<Crypto::Hash::MD5> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::MD5> hmac("Well Hello Friends"sv);
auto mac_0 = hmac.process("Some bogus data");
auto mac_1 = hmac.process("Some bogus data");
auto mac_0 = hmac.process("Some bogus data"sv);
auto mac_1 = hmac.process("Some bogus data"sv);
EXPECT(memcmp(mac_0.data, mac_1.data, hmac.digest_size()) == 0);
}
TEST_CASE(test_hmac_sha1_name)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA1> hmac("Well Hello Friends");
EXPECT_EQ(hmac.class_name(), "HMAC-SHA1");
Crypto::Authentication::HMAC<Crypto::Hash::SHA1> hmac("Well Hello Friends"sv);
EXPECT_EQ(hmac.class_name(), "HMAC-SHA1"sv);
}
TEST_CASE(test_hmac_sha1_process)
@ -76,72 +76,72 @@ TEST_CASE(test_hmac_sha1_process_reuse)
TEST_CASE(test_hmac_sha256_name)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends");
EXPECT_EQ(hmac.class_name(), "HMAC-SHA256");
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends"sv);
EXPECT_EQ(hmac.class_name(), "HMAC-SHA256"sv);
}
TEST_CASE(test_hmac_sha256_process)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends"sv);
u8 result[] {
0x1a, 0xf2, 0x20, 0x62, 0xde, 0x3b, 0x84, 0x65, 0xc1, 0x25, 0x23, 0x99, 0x76, 0x15, 0x1b, 0xec, 0x15, 0x21, 0x82, 0x1f, 0x23, 0xca, 0x11, 0x66, 0xdd, 0x8c, 0x6e, 0xf1, 0x81, 0x3b, 0x7f, 0x1b
};
auto mac = hmac.process("Some bogus data");
auto mac = hmac.process("Some bogus data"sv);
EXPECT(memcmp(result, mac.data, hmac.digest_size()) == 0);
}
TEST_CASE(test_hmac_sha256_reuse)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends"sv);
auto mac_0 = hmac.process("Some bogus data");
auto mac_1 = hmac.process("Some bogus data");
auto mac_0 = hmac.process("Some bogus data"sv);
auto mac_1 = hmac.process("Some bogus data"sv);
EXPECT(memcmp(mac_0.data, mac_1.data, hmac.digest_size()) == 0);
}
TEST_CASE(test_hmac_sha256_data_is_same_size_as_block)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends"sv);
u8 result[] = {
0x1d, 0x90, 0xce, 0x68, 0x45, 0x0b, 0xba, 0xd6, 0xbe, 0x1c, 0xb2, 0x3a, 0xea, 0x7f, 0xac, 0x4b, 0x68, 0x08, 0xa4, 0x77, 0x81, 0x2a, 0xad, 0x5d, 0x05, 0xe2, 0x15, 0xe8, 0xf4, 0xcb, 0x06, 0xaf
};
auto mac = hmac.process("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
auto mac = hmac.process("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"sv);
EXPECT(memcmp(result, mac.data, hmac.digest_size()) == 0);
}
TEST_CASE(test_hmac_sha256_data_is_bigger_size_as_block)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::SHA256> hmac("Well Hello Friends"sv);
u8 result[] = {
0x9b, 0xa3, 0x9e, 0xf3, 0xb4, 0x30, 0x5f, 0x6f, 0x67, 0xd0, 0xa8, 0xb0, 0xf0, 0xcb, 0x12, 0xf5, 0x85, 0xe2, 0x19, 0xba, 0x0c, 0x8b, 0xe5, 0x43, 0xf0, 0x93, 0x39, 0xa8, 0xa3, 0x07, 0xf1, 0x95
};
auto mac = hmac.process("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
auto mac = hmac.process("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"sv);
EXPECT(memcmp(result, mac.data, hmac.digest_size()) == 0);
}
TEST_CASE(test_hmac_sha512_name)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA512> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::SHA512> hmac("Well Hello Friends"sv);
EXPECT_EQ(hmac.class_name(), "HMAC-SHA512");
}
TEST_CASE(test_hmac_sha512_process)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA512> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::SHA512> hmac("Well Hello Friends"sv);
u8 result[] {
0xeb, 0xa8, 0x34, 0x11, 0xfd, 0x5b, 0x46, 0x5b, 0xef, 0xbb, 0x67, 0x5e, 0x7d, 0xc2, 0x7c, 0x2c, 0x6b, 0xe1, 0xcf, 0xe6, 0xc7, 0xe4, 0x7d, 0xeb, 0xca, 0x97, 0xb7, 0x4c, 0xd3, 0x4d, 0x6f, 0x08, 0x9f, 0x0d, 0x3a, 0xf1, 0xcb, 0x00, 0x79, 0x78, 0x2f, 0x05, 0x8e, 0xeb, 0x94, 0x48, 0x0d, 0x50, 0x64, 0x3b, 0xca, 0x70, 0xe2, 0x69, 0x38, 0x4f, 0xe4, 0xb0, 0x49, 0x0f, 0xc5, 0x4c, 0x7a, 0xa7
};
auto mac = hmac.process("Some bogus data");
auto mac = hmac.process("Some bogus data"sv);
EXPECT(memcmp(result, mac.data, hmac.digest_size()) == 0);
}
TEST_CASE(test_hmac_sha512_reuse)
{
Crypto::Authentication::HMAC<Crypto::Hash::SHA512> hmac("Well Hello Friends");
Crypto::Authentication::HMAC<Crypto::Hash::SHA512> hmac("Well Hello Friends"sv);
auto mac_0 = hmac.process("Some bogus data");
auto mac_1 = hmac.process("Some bogus data");
auto mac_0 = hmac.process("Some bogus data"sv);
auto mac_1 = hmac.process("Some bogus data"sv);
EXPECT(memcmp(mac_0.data, mac_1.data, hmac.digest_size()) == 0);
}

80
Tests/LibCrypto/TestHash.cpp
View file

@ -23,7 +23,7 @@ TEST_CASE(test_MD5_hash_string)
u8 result[] {
0xaf, 0x04, 0x3a, 0x08, 0x94, 0x38, 0x6e, 0x7f, 0xbf, 0x73, 0xe4, 0xaa, 0xf0, 0x8e, 0xee, 0x4c
};
auto digest = Crypto::Hash::MD5::hash("Well hello friends");
auto digest = Crypto::Hash::MD5::hash("Well hello friends"sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::MD5::digest_size()) == 0);
}
@ -32,7 +32,7 @@ TEST_CASE(test_MD5_hash_empty_string)
u8 result[] {
0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e
};
auto digest = Crypto::Hash::MD5::hash("");
auto digest = Crypto::Hash::MD5::hash(""sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::MD5::digest_size()) == 0);
}
@ -41,7 +41,7 @@ TEST_CASE(test_MD5_hash_single_character)
u8 result[] {
0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8, 0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61
};
auto digest = Crypto::Hash::MD5::hash("a");
auto digest = Crypto::Hash::MD5::hash("a"sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::MD5::digest_size()) == 0);
}
@ -50,7 +50,7 @@ TEST_CASE(test_MD5_hash_alphabet)
u8 result[] {
0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00, 0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b
};
auto digest = Crypto::Hash::MD5::hash("abcdefghijklmnopqrstuvwxyz");
auto digest = Crypto::Hash::MD5::hash("abcdefghijklmnopqrstuvwxyz"sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::MD5::digest_size()) == 0);
}
@ -59,7 +59,7 @@ TEST_CASE(test_MD5_hash_long_sequence)
u8 result[] {
0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55, 0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a
};
auto digest = Crypto::Hash::MD5::hash("12345678901234567890123456789012345678901234567890123456789012345678901234567890");
auto digest = Crypto::Hash::MD5::hash("12345678901234567890123456789012345678901234567890123456789012345678901234567890"sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::MD5::digest_size()) == 0);
}
@ -70,9 +70,9 @@ TEST_CASE(test_MD5_consecutive_multiple_updates)
};
Crypto::Hash::MD5 md5;
md5.update("Well");
md5.update(" hello ");
md5.update("friends");
md5.update("Well"sv);
md5.update(" hello "sv);
md5.update("friends"sv);
auto digest = md5.digest();
EXPECT(memcmp(result, digest.data, Crypto::Hash::MD5::digest_size()) == 0);
@ -82,14 +82,14 @@ TEST_CASE(test_MD5_consecutive_updates_reuse)
{
Crypto::Hash::MD5 md5;
md5.update("Well");
md5.update(" hello ");
md5.update("friends");
md5.update("Well"sv);
md5.update(" hello "sv);
md5.update("friends"sv);
auto digest0 = md5.digest();
md5.update("Well");
md5.update(" hello ");
md5.update("friends");
md5.update("Well"sv);
md5.update(" hello "sv);
md5.update("friends"sv);
auto digest1 = md5.digest();
EXPECT(memcmp(digest0.data, digest1.data, Crypto::Hash::MD5::digest_size()) == 0);
@ -98,7 +98,7 @@ TEST_CASE(test_MD5_consecutive_updates_reuse)
TEST_CASE(test_SHA1_name)
{
Crypto::Hash::SHA1 sha;
EXPECT(sha.class_name() == "SHA1");
EXPECT(sha.class_name() == "SHA1"sv);
}
TEST_CASE(test_SHA1_hash_empty_string)
@ -106,7 +106,7 @@ TEST_CASE(test_SHA1_hash_empty_string)
u8 result[] {
0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55, 0xbf, 0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09
};
auto digest = Crypto::Hash::SHA1::hash("");
auto digest = Crypto::Hash::SHA1::hash(""sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::SHA1::digest_size()) == 0);
}
@ -115,7 +115,7 @@ TEST_CASE(test_SHA1_hash_long_string)
u8 result[] {
0x12, 0x15, 0x1f, 0xb1, 0x04, 0x44, 0x93, 0xcc, 0xed, 0x54, 0xa6, 0xb8, 0x7e, 0x93, 0x37, 0x7b, 0xb2, 0x13, 0x39, 0xdb
};
auto digest = Crypto::Hash::SHA1::hash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
auto digest = Crypto::Hash::SHA1::hash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::SHA1::digest_size()) == 0);
}
@ -125,19 +125,19 @@ TEST_CASE(test_SHA1_hash_successive_updates)
0xd6, 0x6e, 0xce, 0xd1, 0xf4, 0x08, 0xc6, 0xd8, 0x35, 0xab, 0xf0, 0xc9, 0x05, 0x26, 0xa4, 0xb2, 0xb8, 0xa3, 0x7c, 0xd3
};
auto hasher = Crypto::Hash::SHA1 {};
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa");
hasher.update("aaaaaaaaa");
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaaaaaaaa"sv);
hasher.update("aaaaaaaaa"sv);
auto digest = hasher.digest();
EXPECT(memcmp(result, digest.data, Crypto::Hash::SHA1::digest_size()) == 0);
}
@ -145,7 +145,7 @@ TEST_CASE(test_SHA1_hash_successive_updates)
TEST_CASE(test_SHA256_name)
{
Crypto::Hash::SHA256 sha;
EXPECT_EQ(sha.class_name(), "SHA256");
EXPECT_EQ(sha.class_name(), "SHA256"sv);
}
TEST_CASE(test_SHA256_hash_string)
@ -153,7 +153,7 @@ TEST_CASE(test_SHA256_hash_string)
u8 result[] {
0x9a, 0xcd, 0x50, 0xf9, 0xa2, 0xaf, 0x37, 0xe4, 0x71, 0xf7, 0x61, 0xc3, 0xfe, 0x7b, 0x8d, 0xea, 0x56, 0x17, 0xe5, 0x1d, 0xac, 0x80, 0x2f, 0xe6, 0xc1, 0x77, 0xb7, 0x4a, 0xbf, 0x0a, 0xbb, 0x5a
};
auto digest = Crypto::Hash::SHA256::hash("Well hello friends");
auto digest = Crypto::Hash::SHA256::hash("Well hello friends"sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::SHA256::digest_size()) == 0);
}
@ -162,14 +162,14 @@ TEST_CASE(test_SHA256_hash_empty_string)
u8 result[] {
0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55
};
auto digest = Crypto::Hash::SHA256::hash("");
auto digest = Crypto::Hash::SHA256::hash(""sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::SHA256::digest_size()) == 0);
}
TEST_CASE(test_SHA384_name)
{
Crypto::Hash::SHA384 sha;
EXPECT_EQ(sha.class_name(), "SHA384");
EXPECT_EQ(sha.class_name(), "SHA384"sv);
}
TEST_CASE(test_SHA384_hash_string)
@ -177,7 +177,7 @@ TEST_CASE(test_SHA384_hash_string)
u8 result[] {
0x2f, 0x01, 0x8e, 0x9a, 0x4f, 0xd1, 0x36, 0xb9, 0x0f, 0xcc, 0x21, 0xde, 0x1a, 0xd4, 0x49, 0x51, 0x57, 0x82, 0x86, 0x84, 0x54, 0x09, 0x82, 0x7b, 0x54, 0x56, 0x93, 0xac, 0x2c, 0x46, 0x0c, 0x1f, 0x5e, 0xec, 0xe0, 0xf7, 0x8b, 0x0b, 0x84, 0x27, 0xc8, 0xb8, 0xbe, 0x49, 0xce, 0x8f, 0x1c, 0xff
};
auto digest = Crypto::Hash::SHA384::hash("Well hello friends");
auto digest = Crypto::Hash::SHA384::hash("Well hello friends"sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::SHA384::digest_size()) == 0);
}
@ -187,14 +187,14 @@ TEST_CASE(test_SHA384_hash_bug)
0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8, 0x3d, 0x19, 0x2f, 0xc7, 0x82, 0xcd, 0x1b, 0x47, 0x53, 0x11, 0x1b, 0x17, 0x3b, 0x3b, 0x05, 0xd2, 0x2f, 0xa0, 0x80, 0x86, 0xe3, 0xb0, 0xf7, 0x12, 0xfc, 0xc7, 0xc7, 0x1a, 0x55, 0x7e, 0x2d, 0xb9, 0x66, 0xc3, 0xe9, 0xfa, 0x91, 0x74, 0x60, 0x39
};
ReadonlyBytes result_bytes { result, 48 };
auto digest = Crypto::Hash::SHA384::hash("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
auto digest = Crypto::Hash::SHA384::hash("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"sv);
EXPECT_EQ(result_bytes, digest.bytes());
}
TEST_CASE(test_SHA512_name)
{
Crypto::Hash::SHA512 sha;
EXPECT_EQ(sha.class_name(), "SHA512");
EXPECT_EQ(sha.class_name(), "SHA512"sv);
}
TEST_CASE(test_SHA512_hash_string)
@ -202,7 +202,7 @@ TEST_CASE(test_SHA512_hash_string)
u8 result[] {
0x00, 0xfe, 0x68, 0x09, 0x71, 0x0e, 0xcb, 0x2b, 0xe9, 0x58, 0x00, 0x13, 0x69, 0x6a, 0x9e, 0x9e, 0xbd, 0x09, 0x1b, 0xfe, 0x14, 0xc9, 0x13, 0x82, 0xc7, 0x40, 0x34, 0xfe, 0xca, 0xe6, 0x87, 0xcb, 0x26, 0x36, 0x92, 0xe6, 0x34, 0x94, 0x3a, 0x11, 0xe5, 0xbb, 0xb5, 0xeb, 0x8e, 0x70, 0xef, 0x64, 0xca, 0xf7, 0x21, 0xb1, 0xde, 0xf2, 0x34, 0x85, 0x6f, 0xa8, 0x56, 0xd8, 0x23, 0xa1, 0x3b, 0x29
};
auto digest = Crypto::Hash::SHA512::hash("Well hello friends");
auto digest = Crypto::Hash::SHA512::hash("Well hello friends"sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::SHA512::digest_size()) == 0);
}
@ -212,7 +212,7 @@ TEST_CASE(test_SHA512_hash_bug)
0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda, 0x8c, 0xf4, 0xf7, 0x28, 0x14, 0xfc, 0x14, 0x3f, 0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1, 0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18, 0x50, 0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4, 0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a, 0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54, 0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09
};
ReadonlyBytes result_bytes { result, 64 };
auto digest = Crypto::Hash::SHA512::hash("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
auto digest = Crypto::Hash::SHA512::hash("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"sv);
EXPECT_EQ(result_bytes, digest.bytes());
}
@ -221,7 +221,7 @@ TEST_CASE(test_SHA512_hash_empty_string)
u8 result[] {
0xcf, 0x83, 0xe1, 0x35, 0x7e, 0xef, 0xb8, 0xbd, 0xf1, 0x54, 0x28, 0x50, 0xd6, 0x6d, 0x80, 0x07, 0xd6, 0x20, 0xe4, 0x05, 0x0b, 0x57, 0x15, 0xdc, 0x83, 0xf4, 0xa9, 0x21, 0xd3, 0x6c, 0xe9, 0xce, 0x47, 0xd0, 0xd1, 0x3c, 0x5d, 0x85, 0xf2, 0xb0, 0xff, 0x83, 0x18, 0xd2, 0x87, 0x7e, 0xec, 0x2f, 0x63, 0xb9, 0x31, 0xbd, 0x47, 0x41, 0x7a, 0x81, 0xa5, 0x38, 0x32, 0x7a, 0xf9, 0x27, 0xda, 0x3e
};
auto digest = Crypto::Hash::SHA512::hash("");
auto digest = Crypto::Hash::SHA512::hash(""sv);
EXPECT(memcmp(result, digest.data, Crypto::Hash::SHA512::digest_size()) == 0);
}

4
Tests/LibCrypto/TestRSA.cpp
View file

@ -55,7 +55,7 @@ joNOYoR5R9z5oX2cpcyykQ58FC2vKKg+x8N6xczG7qO95tw5UQIhAN354CP/FA+uTeJ6KJ+i
zCBCl58CjNCzO0s5HTc56el5AiEAsvPKXo5/9gS/S4UzDRP6abq7GreixTfjR8LXidk3FL8C
IQCTjYI861Y+hjMnlORkGSdvWlTHUj6gjEOh4TlWeJzQoQIgAxMZOQKtxCZUuxFwzRq4xLRG
nrDlBQpuxz7bwSyQO7UCIHrYMnDohgNbwtA5ZpW3H1cKKQQvueWm6sxW9P5sUrZ3
-----END RSA PRIVATE KEY-----)";
-----END RSA PRIVATE KEY-----)"sv;
Crypto::PK::RSA rsa(privkey);
if (rsa.public_key().public_exponent() != 65537) {
@ -96,7 +96,7 @@ o+7RC7iOkO+rnzTXwxBSBpXMiUTAIx/hrdfPVxQT+wKBgCh7N3OLIOH6EWcW1fif
UoENh8rkt/kzm89G1JLwBhuBIBPXUEZt2dS/xSUempqVqFGONpP87gvqxkMTtgCA
73KXn/cxHWM2kmXyHA3kQlOYw6WHjpldQAxLE+TRHXO2JUtZ09Mu4rVXX7lmwbTm
l3vmuDEF3/Bo1C1HTg0xRV/l
-----END PRIVATE KEY-----)";
-----END PRIVATE KEY-----)"sv;
Crypto::PK::RSA rsa(privkey);
if (rsa.public_key().public_exponent() != 65537) {

10
Tests/LibGL/TestRender.cpp
View file

@ -70,7 +70,7 @@ TEST_CASE(0001_simple_triangle)
EXPECT_EQ(glGetError(), 0u);
context->present();
expect_bitmap_equals_reference(context->frontbuffer(), "0001_simple_triangle");
expect_bitmap_equals_reference(context->frontbuffer(), "0001_simple_triangle"sv);
}
TEST_CASE(0002_quad_color_interpolation)
@ -92,7 +92,7 @@ TEST_CASE(0002_quad_color_interpolation)
EXPECT_EQ(glGetError(), 0u);
context->present();
expect_bitmap_equals_reference(context->frontbuffer(), "0002_quad_color_interpolation");
expect_bitmap_equals_reference(context->frontbuffer(), "0002_quad_color_interpolation"sv);
}
TEST_CASE(0003_rect_w_coordinate_regression)
@ -115,7 +115,7 @@ TEST_CASE(0003_rect_w_coordinate_regression)
EXPECT_EQ(glGetError(), 0u);
context->present();
expect_bitmap_equals_reference(context->frontbuffer(), "0003_rect_w_coordinate_regression");
expect_bitmap_equals_reference(context->frontbuffer(), "0003_rect_w_coordinate_regression"sv);
}
TEST_CASE(0004_points)
@ -145,7 +145,7 @@ TEST_CASE(0004_points)
EXPECT_EQ(glGetError(), 0u);
context->present();
expect_bitmap_equals_reference(context->frontbuffer(), "0004_points");
expect_bitmap_equals_reference(context->frontbuffer(), "0004_points"sv);
}
TEST_CASE(0005_lines_antialiased)
@ -167,5 +167,5 @@ TEST_CASE(0005_lines_antialiased)
EXPECT_EQ(glGetError(), 0u);
context->present();
expect_bitmap_equals_reference(context->frontbuffer(), "0005_lines");
expect_bitmap_equals_reference(context->frontbuffer(), "0005_lines"sv);
}

8
Tests/LibGfx/TestFontHandling.cpp
View file

@ -14,7 +14,7 @@
TEST_CASE(test_fontdatabase_get_by_name)
{
char const* name = "Liza 10 400 0";
auto name = "Liza 10 400 0"sv;
auto& font_database = Gfx::FontDatabase::the();
EXPECT(!font_database.get_by_name(name)->name().is_null());
}
@ -55,7 +55,7 @@ TEST_CASE(test_set_name)
u8 glyph_width = 1;
auto font = Gfx::BitmapFont::create(glyph_height, glyph_width, true, 256);
char const* name = "my newly created font";
auto name = "my newly created font"sv;
font->set_name(name);
EXPECT(!font->name().is_null());
@ -68,7 +68,7 @@ TEST_CASE(test_set_family)
u8 glyph_width = 1;
auto font = Gfx::BitmapFont::create(glyph_height, glyph_width, true, 256);
char const* family = "my newly created font family";
auto family = "my newly created font family"sv;
font->set_family(family);
EXPECT(!font->family().is_null());
@ -105,7 +105,7 @@ TEST_CASE(test_width)
u8 glyph_width = 1;
auto font = Gfx::BitmapFont::create(glyph_height, glyph_width, true, 256);
EXPECT(font->width("A") == glyph_width);
EXPECT(font->width("A"sv) == glyph_width);
}
TEST_CASE(test_glyph_or_emoji_width)

16
Tests/LibGfx/TestImageDecoder.cpp
View file

@ -23,7 +23,7 @@
TEST_CASE(test_bmp)
{
auto file = Core::MappedFile::map("/res/html/misc/bmpsuite_files/rgba32-1.bmp").release_value();
auto file = Core::MappedFile::map("/res/html/misc/bmpsuite_files/rgba32-1.bmp"sv).release_value();
auto bmp = Gfx::BMPImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(bmp.frame_count());
@ -37,7 +37,7 @@ TEST_CASE(test_bmp)
TEST_CASE(test_gif)
{
auto file = Core::MappedFile::map("/res/graphics/download-animation.gif").release_value();
auto file = Core::MappedFile::map("/res/graphics/download-animation.gif"sv).release_value();
auto gif = Gfx::GIFImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(gif.frame_count());
@ -52,7 +52,7 @@ TEST_CASE(test_gif)
TEST_CASE(test_ico)
{
// FIXME: Use an ico file
auto file = Core::MappedFile::map("/res/graphics/buggie.png").release_value();
auto file = Core::MappedFile::map("/res/graphics/buggie.png"sv).release_value();
auto ico = Gfx::ICOImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(ico.frame_count());
@ -65,7 +65,7 @@ TEST_CASE(test_ico)
TEST_CASE(test_jpg)
{
auto file = Core::MappedFile::map("/res/html/misc/bmpsuite_files/rgb24.jpg").release_value();
auto file = Core::MappedFile::map("/res/html/misc/bmpsuite_files/rgb24.jpg"sv).release_value();
auto jpg = Gfx::JPGImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(jpg.frame_count());
@ -79,7 +79,7 @@ TEST_CASE(test_jpg)
TEST_CASE(test_pbm)
{
auto file = Core::MappedFile::map("/res/html/misc/pbmsuite_files/buggie-raw.pbm").release_value();
auto file = Core::MappedFile::map("/res/html/misc/pbmsuite_files/buggie-raw.pbm"sv).release_value();
auto pbm = Gfx::PBMImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(pbm.frame_count());
@ -93,7 +93,7 @@ TEST_CASE(test_pbm)
TEST_CASE(test_pgm)
{
auto file = Core::MappedFile::map("/res/html/misc/pgmsuite_files/buggie-raw.pgm").release_value();
auto file = Core::MappedFile::map("/res/html/misc/pgmsuite_files/buggie-raw.pgm"sv).release_value();
auto pgm = Gfx::PGMImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(pgm.frame_count());
@ -107,7 +107,7 @@ TEST_CASE(test_pgm)
TEST_CASE(test_png)
{
auto file = Core::MappedFile::map("/res/graphics/buggie.png").release_value();
auto file = Core::MappedFile::map("/res/graphics/buggie.png"sv).release_value();
auto png = Gfx::PNGImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(png.frame_count());
@ -121,7 +121,7 @@ TEST_CASE(test_png)
TEST_CASE(test_ppm)
{
auto file = Core::MappedFile::map("/res/html/misc/ppmsuite_files/buggie-raw.ppm").release_value();
auto file = Core::MappedFile::map("/res/html/misc/ppmsuite_files/buggie-raw.ppm"sv).release_value();
auto ppm = Gfx::PPMImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(ppm.frame_count());

20
Tests/LibJS/test-bytecode-js.cpp
View file

@ -11,15 +11,15 @@
#include <LibJS/Script.h>
#include <LibTest/TestCase.h>
#define SETUP_AND_PARSE(source) \
auto vm = JS::VM::create(); \
auto ast_interpreter = JS::Interpreter::create<JS::GlobalObject>(*vm); \
\
auto script_or_error = JS::Script::parse(source, ast_interpreter->realm()); \
EXPECT(!script_or_error.is_error()); \
\
auto script = script_or_error.release_value(); \
auto const& program = script->parse_node(); \
#define SETUP_AND_PARSE(source) \
auto vm = JS::VM::create(); \
auto ast_interpreter = JS::Interpreter::create<JS::GlobalObject>(*vm); \
\
auto script_or_error = JS::Script::parse(source##sv, ast_interpreter->realm()); \
EXPECT(!script_or_error.is_error()); \
\
auto script = script_or_error.release_value(); \
auto const& program = script->parse_node(); \
JS::Bytecode::Interpreter bytecode_interpreter(ast_interpreter->global_object(), ast_interpreter->realm());
#define EXPECT_NO_EXCEPTION(executable) \
@ -110,7 +110,7 @@ TEST_CASE(loading_multiple_files)
}
{
auto test_file_script_or_error = JS::Script::parse("if (f() !== 'hello') throw new Exception('failed'); ", ast_interpreter->realm());
auto test_file_script_or_error = JS::Script::parse("if (f() !== 'hello') throw new Exception('failed'); "sv, ast_interpreter->realm());
EXPECT(!test_file_script_or_error.is_error());
auto test_file_script = test_file_script_or_error.release_value();

4
Tests/LibJS/test-invalid-unicode-js.cpp
View file

@ -37,7 +37,7 @@ static bool triggers_immediate_unicode_fault(StringView code)
TEST_CASE(no_input_only_gives_eof)
{
char const* code = "";
auto code = ""sv;
auto lexer = JS::Lexer(code);
EXPECT(produces_eof_tokens(lexer));
}
@ -134,7 +134,7 @@ TEST_CASE(long_invalid_unicode_and_valid_code)
TEST_CASE(invalid_unicode_after_valid_code_and_before_eof)
{
char const* code = "let \xEA\xFD;";
auto code = "let \xEA\xFD;"sv;
auto lexer = JS::Lexer(code);
auto let_token = lexer.next();
EXPECT_EQ(let_token.type(), JS::TokenType::Let);

10
Tests/LibJS/test-js.cpp
View file

@ -104,18 +104,18 @@ TESTJS_RUN_FILE_FUNCTION(String const& test_file, JS::Interpreter& interpreter,
ExplicitPass,
} expectation { Pass };
if (dirname.ends_with("early"))
if (dirname.ends_with("early"sv))
expectation = Early;
else if (dirname.ends_with("fail"))
else if (dirname.ends_with("fail"sv))
expectation = Fail;
else if (dirname.ends_with("pass-explicit"))
else if (dirname.ends_with("pass-explicit"sv))
expectation = ExplicitPass;
else if (dirname.ends_with("pass"))
else if (dirname.ends_with("pass"sv))
expectation = Pass;
else
return Test::JS::RunFileHookResult::SkipFile;
auto program_type = path.basename().ends_with(".module.js") ? JS::Program::Type::Module : JS::Program::Type::Script;
auto program_type = path.basename().ends_with(".module.js"sv) ? JS::Program::Type::Module : JS::Program::Type::Script;
bool parse_succeeded = false;
if (program_type == JS::Program::Type::Module)
parse_succeeded = !Test::JS::parse_module(test_file, interpreter.realm()).is_error();

8
Tests/LibM/test-math.cpp
View file

@ -130,13 +130,13 @@ template<>
struct Formatter<Extractor> : StandardFormatter {
ErrorOr<void> format(FormatBuilder& builder, Extractor const& value)
{
TRY(builder.put_literal("{"));
TRY(builder.put_literal("{"sv));
TRY(builder.put_u64(value.sign));
TRY(builder.put_literal(", "));
TRY(builder.put_literal(", "sv));
TRY(builder.put_u64(value.exponent, 16, true));
TRY(builder.put_literal(", "));
TRY(builder.put_literal(", "sv));
TRY(builder.put_u64(value.mantissa, 16, true));
TRY(builder.put_literal("}"));
TRY(builder.put_literal("}"sv));
return {};
}
};

16
Tests/LibMarkdown/TestCommonmark.cpp
View file

@ -15,9 +15,9 @@
TEST_SETUP
{
auto file_or_error = Core::Stream::File::open("/home/anon/Tests/commonmark.spec.json", Core::Stream::OpenMode::Read);
auto file_or_error = Core::Stream::File::open("/home/anon/Tests/commonmark.spec.json"sv, Core::Stream::OpenMode::Read);
if (file_or_error.is_error())
file_or_error = Core::Stream::File::open("./commonmark.spec.json", Core::Stream::OpenMode::Read);
file_or_error = Core::Stream::File::open("./commonmark.spec.json"sv, Core::Stream::OpenMode::Read);
VERIFY(!file_or_error.is_error());
auto file = file_or_error.release_value();
auto file_size = MUST(file->size());
@ -31,13 +31,13 @@ TEST_SETUP
auto testcase = tests[i].as_object();
auto name = String::formatted("{}_ex{}_{}..{}",
testcase.get("section"),
testcase.get("example"),
testcase.get("start_line"),
testcase.get("end_line"));
testcase.get("section"sv),
testcase.get("example"sv),
testcase.get("start_line"sv),
testcase.get("end_line"sv));
String markdown = testcase.get("markdown").as_string();
String html = testcase.get("html").as_string();
String markdown = testcase.get("markdown"sv).as_string();
String html = testcase.get("html"sv).as_string();
Test::TestSuite::the().add_case(adopt_ref(*new Test::TestCase(
name, [markdown, html]() {

6
Tests/LibPDF/TestPDF.cpp
View file

@ -13,7 +13,7 @@
TEST_CASE(linearized_pdf)
{
auto file = Core::MappedFile::map("linearized.pdf").release_value();
auto file = Core::MappedFile::map("linearized.pdf"sv).release_value();
auto document = PDF::Document::create(file->bytes());
EXPECT(!document.is_error());
EXPECT(!document.value()->initialize().is_error());
@ -22,7 +22,7 @@ TEST_CASE(linearized_pdf)
TEST_CASE(non_linearized_pdf)
{
auto file = Core::MappedFile::map("non-linearized.pdf").release_value();
auto file = Core::MappedFile::map("non-linearized.pdf"sv).release_value();
auto document = PDF::Document::create(file->bytes());
EXPECT(!document.is_error());
EXPECT(!document.value()->initialize().is_error());
@ -31,7 +31,7 @@ TEST_CASE(non_linearized_pdf)
TEST_CASE(complex_pdf)
{
auto file = Core::MappedFile::map("complex.pdf").release_value();
auto file = Core::MappedFile::map("complex.pdf"sv).release_value();
auto document = PDF::Document::create(file->bytes());
EXPECT(!document.is_error());
EXPECT(!document.value()->initialize().is_error());

94
Tests/LibRegex/Regex.cpp
View file

@ -96,7 +96,7 @@ TEST_CASE(regex_options_posix)
TEST_CASE(regex_lexer)
{
Lexer l("/[.*+?^${}()|[\\]\\\\]/g");
Lexer l("/[.*+?^${}()|[\\]\\\\]/g"sv);
EXPECT(l.next().type() == regex::TokenType::Slash);
EXPECT(l.next().type() == regex::TokenType::LeftBracket);
EXPECT(l.next().type() == regex::TokenType::Period);
@ -149,7 +149,7 @@ TEST_CASE(parser_error_special_characters_used_at_wrong_place)
// After vertical line
b.clear();
b.append("a|");
b.append("a|"sv);
b.append(ch);
pattern = b.build();
l.set_source(pattern);
@ -196,25 +196,25 @@ TEST_CASE(parser_error_vertical_line_used_at_wrong_place)
PosixExtended p(l);
// First in ere
l.set_source("|asdf");
l.set_source("|asdf"sv);
p.parse();
EXPECT(p.has_error());
EXPECT(p.error() == regex::Error::EmptySubExpression);
// Last in ere
l.set_source("asdf|");
l.set_source("asdf|"sv);
p.parse();
EXPECT(p.has_error());
EXPECT(p.error() == regex::Error::EmptySubExpression);
// After left parens
l.set_source("(|asdf)");
l.set_source("(|asdf)"sv);
p.parse();
EXPECT(p.has_error());
EXPECT(p.error() == regex::Error::EmptySubExpression);
// Proceed right parens
l.set_source("(asdf)|");
l.set_source("(asdf)|"sv);
p.parse();
EXPECT(p.has_error());
EXPECT(p.error() == regex::Error::EmptySubExpression);
@ -224,21 +224,21 @@ TEST_CASE(catch_all_first)
{
Regex<PosixExtended> re("^.*$");
RegexResult m;
re.match("Hello World", m);
re.match("Hello World"sv, m);
EXPECT(m.count == 1);
EXPECT(re.match("Hello World", m));
EXPECT(re.match("Hello World"sv, m));
}
TEST_CASE(catch_all)
{
Regex<PosixExtended> re("^.*$", PosixFlags::Global);
EXPECT(re.has_match("Hello World"));
EXPECT(re.match("Hello World").success);
EXPECT(re.match("Hello World").count == 1);
EXPECT(re.has_match("Hello World"sv));
EXPECT(re.match("Hello World"sv).success);
EXPECT(re.match("Hello World"sv).count == 1);
EXPECT(has_match("Hello World", re));
auto res = match("Hello World", re);
EXPECT(has_match("Hello World"sv, re));
auto res = match("Hello World"sv, re);
EXPECT(res.success);
EXPECT(res.count == 1);
EXPECT(res.matches.size() == 1);
@ -248,7 +248,7 @@ TEST_CASE(catch_all)
TEST_CASE(catch_all_again)
{
Regex<PosixExtended> re("^.*$", PosixFlags::Extra);
EXPECT_EQ(has_match("Hello World", re), true);
EXPECT_EQ(has_match("Hello World"sv, re), true);
}
TEST_CASE(char_utf8)
@ -295,14 +295,14 @@ TEST_CASE(catch_all_newline_2)
{
Regex<PosixExtended> re("^.*$");
RegexResult result;
result = match("Hello World\nTest\n1234\n", re, PosixFlags::Multiline | PosixFlags::StringCopyMatches);
result = match("Hello World\nTest\n1234\n"sv, re, PosixFlags::Multiline | PosixFlags::StringCopyMatches);
EXPECT_EQ(result.success, true);
EXPECT_EQ(result.count, 3u);
EXPECT_EQ(result.matches.at(0).view, "Hello World");
EXPECT_EQ(result.matches.at(1).view, "Test");
EXPECT_EQ(result.matches.at(2).view, "1234");
result = match("Hello World\nTest\n1234\n", re);
result = match("Hello World\nTest\n1234\n"sv, re);
EXPECT_EQ(result.success, true);
EXPECT_EQ(result.count, 1u);
EXPECT_EQ(result.matches.at(0).view, "Hello World\nTest\n1234\n");
@ -334,16 +334,16 @@ TEST_CASE(match_character_class_with_assertion)
TEST_CASE(example_for_git_commit)
{
Regex<PosixExtended> re("^.*$");
auto result = re.match("Well, hello friends!\nHello World!");
auto result = re.match("Well, hello friends!\nHello World!"sv);
EXPECT(result.success);
EXPECT(result.count == 1);
EXPECT(result.matches.at(0).view.starts_with("Well"));
EXPECT(result.matches.at(0).view.starts_with("Well"sv));
EXPECT(result.matches.at(0).view.length() == 33);
EXPECT(re.has_match("Well,...."));
EXPECT(re.has_match("Well,...."sv));
result = re.match("Well, hello friends!\nHello World!", PosixFlags::Multiline);
result = re.match("Well, hello friends!\nHello World!"sv, PosixFlags::Multiline);
EXPECT(result.success);
EXPECT(result.count == 2);
@ -354,8 +354,8 @@ TEST_CASE(example_for_git_commit)
TEST_CASE(email_address)
{
Regex<PosixExtended> re("^[A-Z0-9a-z._%+-]{1,64}@([A-Za-z0-9-]{1,63}\\.){1,125}[A-Za-z]{2,63}$");
EXPECT(re.has_match("hello.world@domain.tld"));
EXPECT(re.has_match("this.is.a.very_long_email_address@world.wide.web"));
EXPECT(re.has_match("hello.world@domain.tld"sv));
EXPECT(re.has_match("this.is.a.very_long_email_address@world.wide.web"sv));
}
TEST_CASE(ini_file_entries)
@ -480,16 +480,16 @@ TEST_CASE(simple_period_end_benchmark)
{
Regex<PosixExtended> re("hello.$");
RegexResult m;
EXPECT_EQ(re.search("Hello1", m), false);
EXPECT_EQ(re.search("hello1hello1", m), true);
EXPECT_EQ(re.search("hello2hell", m), false);
EXPECT_EQ(re.search("hello?", m), true);
EXPECT_EQ(re.search("Hello1"sv, m), false);
EXPECT_EQ(re.search("hello1hello1"sv, m), true);
EXPECT_EQ(re.search("hello2hell"sv, m), false);
EXPECT_EQ(re.search("hello?"sv, m), true);
}
TEST_CASE(posix_extended_nested_capture_group)
{
Regex<PosixExtended> re("(h(e(?<llo>llo)))"); // group 0 -> "hello", group 1 -> "ello", group 2/"llo" -> "llo"
auto result = re.match("hello");
auto result = re.match("hello"sv);
EXPECT(result.success);
EXPECT_EQ(result.capture_group_matches.size(), 1u);
EXPECT_EQ(result.capture_group_matches[0].size(), 3u);
@ -661,7 +661,7 @@ TEST_CASE(ECMA262_match)
{ "(a{3}){2}"sv, "aaaabaa"sv, false },
{ "(a{4}){2}"sv, "aaaaaaaa"sv },
{ "(a{4}){2}"sv, "aaaaaabaa"sv, false },
{ "\\u{4}"sv, "uuuu" },
{ "\\u{4}"sv, "uuuu"sv },
{ "(?<=.{3})f"sv, "abcdef"sv, true, (ECMAScriptFlags)regex::AllFlags::Global },
{ "(?<=.{3})f"sv, "abc😀ef"sv, true, (ECMAScriptFlags)regex::AllFlags::Global },
// ECMA262, B.1.4. Regular Expression Pattern extensions for browsers
@ -876,7 +876,7 @@ TEST_CASE(replace)
TEST_CASE(case_insensitive_match)
{
Regex<PosixExtended> re("cd", PosixFlags::Insensitive | PosixFlags::Global);
auto result = re.match("AEKFCD");
auto result = re.match("AEKFCD"sv);
EXPECT_EQ(result.success, true);
if (result.success) {
@ -901,7 +901,7 @@ TEST_CASE(theoretically_infinite_loop)
};
for (auto& pattern : patterns) {
Regex<ECMA262> re(pattern);
auto result = re.match("");
auto result = re.match(""sv);
EXPECT_EQ(result.success, true);
}
}
@ -985,10 +985,10 @@ TEST_CASE(posix_basic_dollar_is_end_anchor)
// Ensure that a dollar sign at the end only matches the end of the line.
{
Regex<PosixBasic> re("abc$");
EXPECT_EQ(re.match("123abcdef", PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc", PosixFlags::Global).success, true);
EXPECT_EQ(re.match("123abc$def", PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc$", PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abcdef"sv, PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc"sv, PosixFlags::Global).success, true);
EXPECT_EQ(re.match("123abc$def"sv, PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc$"sv, PosixFlags::Global).success, false);
}
}
@ -997,19 +997,19 @@ TEST_CASE(posix_basic_dollar_is_literal)
// Ensure that a dollar sign in the middle is treated as a literal.
{
Regex<PosixBasic> re("abc$d");
EXPECT_EQ(re.match("123abcdef", PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc", PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc$def", PosixFlags::Global).success, true);
EXPECT_EQ(re.match("123abc$", PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abcdef"sv, PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc"sv, PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc$def"sv, PosixFlags::Global).success, true);
EXPECT_EQ(re.match("123abc$"sv, PosixFlags::Global).success, false);
}
// Ensure that a dollar sign is always treated as a literal if escaped, even if at the end of the pattern.
{
Regex<PosixBasic> re("abc\\$");
EXPECT_EQ(re.match("123abcdef", PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc", PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc$def", PosixFlags::Global).success, true);
EXPECT_EQ(re.match("123abc$", PosixFlags::Global).success, true);
EXPECT_EQ(re.match("123abcdef"sv, PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc"sv, PosixFlags::Global).success, false);
EXPECT_EQ(re.match("123abc$def"sv, PosixFlags::Global).success, true);
EXPECT_EQ(re.match("123abc$"sv, PosixFlags::Global).success, true);
}
}
@ -1020,9 +1020,9 @@ TEST_CASE(negative_lookahead)
auto options = ECMAScriptOptions { ECMAScriptFlags::Global };
options.reset_flag((ECMAScriptFlags)regex::AllFlags::Internal_Stateful);
Regex<ECMA262> re(":(?!\\^\\)|1)", options);
EXPECT_EQ(re.match(":^)").success, false);
EXPECT_EQ(re.match(":1").success, false);
EXPECT_EQ(re.match(":foobar").success, true);
EXPECT_EQ(re.match(":^)"sv).success, false);
EXPECT_EQ(re.match(":1"sv).success, false);
EXPECT_EQ(re.match(":foobar"sv).success, true);
}
}
@ -1031,7 +1031,7 @@ TEST_CASE(single_match_flag)
{
// Ensure that only a single match is produced and nothing past that.
Regex<ECMA262> re("[\\u0008-\\uffff]"sv, ECMAScriptFlags::Global | (ECMAScriptFlags)regex::AllFlags::SingleMatch);
auto result = re.match("ABC");
auto result = re.match("ABC"sv);
EXPECT_EQ(result.success, true);
EXPECT_EQ(result.matches.size(), 1u);
EXPECT_EQ(result.matches.first().view.to_string(), "A"sv);
@ -1044,7 +1044,7 @@ TEST_CASE(inversion_state_in_char_class)
// #13755, /[\S\s]/.exec("hello") should be [ "h" ], not null.
Regex<ECMA262> re("[\\S\\s]", ECMAScriptFlags::Global | (ECMAScriptFlags)regex::AllFlags::SingleMatch);
auto result = re.match("hello");
auto result = re.match("hello"sv);
EXPECT_EQ(result.success, true);
EXPECT_EQ(result.matches.size(), 1u);
EXPECT_EQ(result.matches.first().view.to_string(), "h"sv);

2
Tests/LibRegex/RegexLibC.cpp
View file

@ -332,7 +332,7 @@ TEST_CASE(parser_error_special_characters_used_at_wrong_place)
// After vertical line
b.clear();
b.append("a|");
b.append("a|"sv);
b.append(ch);
pattern = b.build();
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), error_code_to_check);

350
Tests/LibSQL/TestSqlExpressionParser.cpp
View file

@ -53,9 +53,9 @@ TEST_CASE(numeric_literal)
// This is obviously inconsistent.
// See the FIXME in lexer.cpp, method consume_exponent() about
// solutions.
// EXPECT(parse("1e").is_error());
// EXPECT(parse("1a").is_error());
// EXPECT(parse("0x").is_error());
// EXPECT(parse("1e"sv).is_error());
// EXPECT(parse("1a"sv).is_error());
// EXPECT(parse("0x"sv).is_error());
auto validate = [](StringView sql, double expected_value) {
auto result = parse(sql);
@ -68,18 +68,18 @@ TEST_CASE(numeric_literal)
EXPECT_EQ(literal.value(), expected_value);
};
validate("123", 123);
validate("3.14", 3.14);
validate("0xA", 10);
validate("0xff", 255);
validate("0x100", 256);
validate("1e3", 1000);
validate("123"sv, 123);
validate("3.14"sv, 3.14);
validate("0xA"sv, 10);
validate("0xff"sv, 255);
validate("0x100"sv, 256);
validate("1e3"sv, 1000);
}
TEST_CASE(string_literal)
{
EXPECT(parse("'").is_error());
EXPECT(parse("'unterminated").is_error());
EXPECT(parse("'"sv).is_error());
EXPECT(parse("'unterminated"sv).is_error());
auto validate = [](StringView sql, StringView expected_value) {
auto result = parse(sql);
@ -92,16 +92,16 @@ TEST_CASE(string_literal)
EXPECT_EQ(literal.value(), expected_value);
};
validate("''", "");
validate("'hello friends'", "hello friends");
validate("'hello ''friends'''", "hello 'friends'");
validate("''"sv, ""sv);
validate("'hello friends'"sv, "hello friends"sv);
validate("'hello ''friends'''"sv, "hello 'friends'"sv);
}
TEST_CASE(blob_literal)
{
EXPECT(parse("x'").is_error());
EXPECT(parse("x'unterminated").is_error());
EXPECT(parse("x'NOTHEX'").is_error());
EXPECT(parse("x'"sv).is_error());
EXPECT(parse("x'unterminated"sv).is_error());
EXPECT(parse("x'NOTHEX'"sv).is_error());
auto validate = [](StringView sql, StringView expected_value) {
auto result = parse(sql);
@ -114,8 +114,8 @@ TEST_CASE(blob_literal)
EXPECT_EQ(literal.value(), expected_value);
};
validate("x''", "");
validate("x'DEADC0DE'", "DEADC0DE");
validate("x''"sv, ""sv);
validate("x'DEADC0DE'"sv, "DEADC0DE"sv);
}
TEST_CASE(null_literal)
@ -128,15 +128,15 @@ TEST_CASE(null_literal)
EXPECT(is<SQL::AST::NullLiteral>(*expression));
};
validate("NULL");
validate("NULL"sv);
}
TEST_CASE(column_name)
{
EXPECT(parse(".column_name").is_error());
EXPECT(parse("table_name.").is_error());
EXPECT(parse("schema_name.table_name.").is_error());
EXPECT(parse("\"unterminated").is_error());
EXPECT(parse(".column_name"sv).is_error());
EXPECT(parse("table_name."sv).is_error());
EXPECT(parse("schema_name.table_name."sv).is_error());
EXPECT(parse("\"unterminated"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column) {
auto result = parse(sql);
@ -151,22 +151,22 @@ TEST_CASE(column_name)
EXPECT_EQ(column.column_name(), expected_column);
};
validate("column_name", {}, {}, "COLUMN_NAME");
validate("table_name.column_name", {}, "TABLE_NAME", "COLUMN_NAME");
validate("schema_name.table_name.column_name", "SCHEMA_NAME", "TABLE_NAME", "COLUMN_NAME");
validate("\"Column_Name\"", {}, {}, "Column_Name");
validate("\"Column\n_Name\"", {}, {}, "Column\n_Name");
validate("column_name"sv, {}, {}, "COLUMN_NAME"sv);
validate("table_name.column_name"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv);
validate("schema_name.table_name.column_name"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv);
validate("\"Column_Name\""sv, {}, {}, "Column_Name"sv);
validate("\"Column\n_Name\""sv, {}, {}, "Column\n_Name"sv);
}
TEST_CASE(unary_operator)
{
EXPECT(parse("-").is_error());
EXPECT(parse("--").is_error());
EXPECT(parse("+").is_error());
EXPECT(parse("++").is_error());
EXPECT(parse("~").is_error());
EXPECT(parse("~~").is_error());
EXPECT(parse("NOT").is_error());
EXPECT(parse("-"sv).is_error());
EXPECT(parse("--"sv).is_error());
EXPECT(parse("+"sv).is_error());
EXPECT(parse("++"sv).is_error());
EXPECT(parse("~"sv).is_error());
EXPECT(parse("~~"sv).is_error());
EXPECT(parse("NOT"sv).is_error());
auto validate = [](StringView sql, SQL::AST::UnaryOperator expected_operator) {
auto result = parse(sql);
@ -182,42 +182,42 @@ TEST_CASE(unary_operator)
EXPECT(!is<SQL::AST::ErrorExpression>(*secondary_expression));
};
validate("-15", SQL::AST::UnaryOperator::Minus);
validate("+15", SQL::AST::UnaryOperator::Plus);
validate("~15", SQL::AST::UnaryOperator::BitwiseNot);
validate("NOT 15", SQL::AST::UnaryOperator::Not);
validate("-15"sv, SQL::AST::UnaryOperator::Minus);
validate("+15"sv, SQL::AST::UnaryOperator::Plus);
validate("~15"sv, SQL::AST::UnaryOperator::BitwiseNot);
validate("NOT 15"sv, SQL::AST::UnaryOperator::Not);
}
TEST_CASE(binary_operator)
{
HashMap<StringView, SQL::AST::BinaryOperator> operators {
{ "||", SQL::AST::BinaryOperator::Concatenate },
{ "*", SQL::AST::BinaryOperator::Multiplication },
{ "/", SQL::AST::BinaryOperator::Division },
{ "%", SQL::AST::BinaryOperator::Modulo },
{ "+", SQL::AST::BinaryOperator::Plus },
{ "-", SQL::AST::BinaryOperator::Minus },
{ "<<", SQL::AST::BinaryOperator::ShiftLeft },
{ ">>", SQL::AST::BinaryOperator::ShiftRight },
{ "&", SQL::AST::BinaryOperator::BitwiseAnd },
{ "|", SQL::AST::BinaryOperator::BitwiseOr },
{ "<", SQL::AST::BinaryOperator::LessThan },
{ "<=", SQL::AST::BinaryOperator::LessThanEquals },
{ ">", SQL::AST::BinaryOperator::GreaterThan },
{ ">=", SQL::AST::BinaryOperator::GreaterThanEquals },
{ "=", SQL::AST::BinaryOperator::Equals },
{ "==", SQL::AST::BinaryOperator::Equals },
{ "!=", SQL::AST::BinaryOperator::NotEquals },
{ "<>", SQL::AST::BinaryOperator::NotEquals },
{ "AND", SQL::AST::BinaryOperator::And },
{ "OR", SQL::AST::BinaryOperator::Or },
{ "||"sv, SQL::AST::BinaryOperator::Concatenate },
{ "*"sv, SQL::AST::BinaryOperator::Multiplication },
{ "/"sv, SQL::AST::BinaryOperator::Division },
{ "%"sv, SQL::AST::BinaryOperator::Modulo },
{ "+"sv, SQL::AST::BinaryOperator::Plus },
{ "-"sv, SQL::AST::BinaryOperator::Minus },
{ "<<"sv, SQL::AST::BinaryOperator::ShiftLeft },
{ ">>"sv, SQL::AST::BinaryOperator::ShiftRight },
{ "&"sv, SQL::AST::BinaryOperator::BitwiseAnd },
{ "|"sv, SQL::AST::BinaryOperator::BitwiseOr },
{ "<"sv, SQL::AST::BinaryOperator::LessThan },
{ "<="sv, SQL::AST::BinaryOperator::LessThanEquals },
{ ">"sv, SQL::AST::BinaryOperator::GreaterThan },
{ ">="sv, SQL::AST::BinaryOperator::GreaterThanEquals },
{ "="sv, SQL::AST::BinaryOperator::Equals },
{ "=="sv, SQL::AST::BinaryOperator::Equals },
{ "!="sv, SQL::AST::BinaryOperator::NotEquals },
{ "<>"sv, SQL::AST::BinaryOperator::NotEquals },
{ "AND"sv, SQL::AST::BinaryOperator::And },
{ "OR"sv, SQL::AST::BinaryOperator::Or },
};
for (auto op : operators) {
EXPECT(parse(op.key).is_error());
StringBuilder builder;
builder.append("1 ");
builder.append("1 "sv);
builder.append(op.key);
EXPECT(parse(builder.build()).is_error());
@ -225,7 +225,7 @@ TEST_CASE(binary_operator)
if (op.key != "+" && op.key != "-") { // "+1" and "-1" are fine (unary operator).
builder.append(op.key);
builder.append(" 1");
builder.append(" 1"sv);
EXPECT(parse(builder.build()).is_error());
}
}
@ -245,18 +245,18 @@ TEST_CASE(binary_operator)
for (auto op : operators) {
StringBuilder builder;
builder.append("1 ");
builder.append("1 "sv);
builder.append(op.key);
builder.append(" 1");
builder.append(" 1"sv);
validate(builder.build(), op.value);
}
}
TEST_CASE(chained_expression)
{
EXPECT(parse("()").is_error());
EXPECT(parse("(,)").is_error());
EXPECT(parse("(15,)").is_error());
EXPECT(parse("()"sv).is_error());
EXPECT(parse("(,)"sv).is_error());
EXPECT(parse("(15,)"sv).is_error());
auto validate = [](StringView sql, size_t expected_chain_size) {
auto result = parse(sql);
@ -272,20 +272,20 @@ TEST_CASE(chained_expression)
EXPECT(!is<SQL::AST::ErrorExpression>(chained_expression));
};
validate("(15)", 1);
validate("(15, 16)", 2);
validate("(15, 16, column_name)", 3);
validate("(15)"sv, 1);
validate("(15, 16)"sv, 2);
validate("(15, 16, column_name)"sv, 3);
}
TEST_CASE(cast_expression)
{
EXPECT(parse("CAST").is_error());
EXPECT(parse("CAST (").is_error());
EXPECT(parse("CAST ()").is_error());
EXPECT(parse("CAST (15)").is_error());
EXPECT(parse("CAST (15 AS").is_error());
EXPECT(parse("CAST (15 AS)").is_error());
EXPECT(parse("CAST (15 AS int").is_error());
EXPECT(parse("CAST"sv).is_error());
EXPECT(parse("CAST ("sv).is_error());
EXPECT(parse("CAST ()"sv).is_error());
EXPECT(parse("CAST (15)"sv).is_error());
EXPECT(parse("CAST (15 AS"sv).is_error());
EXPECT(parse("CAST (15 AS)"sv).is_error());
EXPECT(parse("CAST (15 AS int"sv).is_error());
auto validate = [](StringView sql, StringView expected_type_name) {
auto result = parse(sql);
@ -303,25 +303,25 @@ TEST_CASE(cast_expression)
EXPECT_EQ(type_name->name(), expected_type_name);
};
validate("CAST (15 AS int)", "INT");
validate("CAST (15 AS int)"sv, "INT"sv);
// FIXME The syntax in the test below fails on both sqlite3 and psql (PostgreSQL).
// Also fails here because null is interpreted as the NULL keyword and not the
// identifier null (which is not a type)
// validate("CAST ('NULL' AS null)", "null");
validate("CAST (15 AS varchar(255))", "VARCHAR");
// validate("CAST ('NULL' AS null)"sv, "null"sv);
validate("CAST (15 AS varchar(255))"sv, "VARCHAR"sv);
}
TEST_CASE(case_expression)
{
EXPECT(parse("CASE").is_error());
EXPECT(parse("CASE END").is_error());
EXPECT(parse("CASE 15").is_error());
EXPECT(parse("CASE 15 END").is_error());
EXPECT(parse("CASE WHEN").is_error());
EXPECT(parse("CASE WHEN THEN").is_error());
EXPECT(parse("CASE WHEN 15 THEN 16").is_error());
EXPECT(parse("CASE WHEN 15 THEN 16 ELSE").is_error());
EXPECT(parse("CASE WHEN 15 THEN 16 ELSE END").is_error());
EXPECT(parse("CASE"sv).is_error());
EXPECT(parse("CASE END"sv).is_error());
EXPECT(parse("CASE 15"sv).is_error());
EXPECT(parse("CASE 15 END"sv).is_error());
EXPECT(parse("CASE WHEN"sv).is_error());
EXPECT(parse("CASE WHEN THEN"sv).is_error());
EXPECT(parse("CASE WHEN 15 THEN 16"sv).is_error());
EXPECT(parse("CASE WHEN 15 THEN 16 ELSE"sv).is_error());
EXPECT(parse("CASE WHEN 15 THEN 16 ELSE END"sv).is_error());
auto validate = [](StringView sql, bool expect_case_expression, size_t expected_when_then_size, bool expect_else_expression) {
auto result = parse(sql);
@ -350,31 +350,31 @@ TEST_CASE(case_expression)
EXPECT(!is<SQL::AST::ErrorExpression>(*else_expression));
};
validate("CASE WHEN 16 THEN 17 END", false, 1, false);
validate("CASE WHEN 16 THEN 17 WHEN 18 THEN 19 END", false, 2, false);
validate("CASE WHEN 16 THEN 17 WHEN 18 THEN 19 ELSE 20 END", false, 2, true);
validate("CASE WHEN 16 THEN 17 END"sv, false, 1, false);
validate("CASE WHEN 16 THEN 17 WHEN 18 THEN 19 END"sv, false, 2, false);
validate("CASE WHEN 16 THEN 17 WHEN 18 THEN 19 ELSE 20 END"sv, false, 2, true);
validate("CASE 15 WHEN 16 THEN 17 END", true, 1, false);
validate("CASE 15 WHEN 16 THEN 17 WHEN 18 THEN 19 END", true, 2, false);
validate("CASE 15 WHEN 16 THEN 17 WHEN 18 THEN 19 ELSE 20 END", true, 2, true);
validate("CASE 15 WHEN 16 THEN 17 END"sv, true, 1, false);
validate("CASE 15 WHEN 16 THEN 17 WHEN 18 THEN 19 END"sv, true, 2, false);
validate("CASE 15 WHEN 16 THEN 17 WHEN 18 THEN 19 ELSE 20 END"sv, true, 2, true);
}
TEST_CASE(exists_expression)
{
EXPECT(parse("EXISTS").is_error());
EXPECT(parse("EXISTS (").is_error());
EXPECT(parse("EXISTS (SELECT").is_error());
EXPECT(parse("EXISTS (SELECT)").is_error());
EXPECT(parse("EXISTS (SELECT * FROM table_name").is_error());
EXPECT(parse("NOT EXISTS").is_error());
EXPECT(parse("NOT EXISTS (").is_error());
EXPECT(parse("NOT EXISTS (SELECT").is_error());
EXPECT(parse("NOT EXISTS (SELECT)").is_error());
EXPECT(parse("NOT EXISTS (SELECT * FROM table_name").is_error());
EXPECT(parse("(").is_error());
EXPECT(parse("(SELECT").is_error());
EXPECT(parse("(SELECT)").is_error());
EXPECT(parse("(SELECT * FROM table_name").is_error());
EXPECT(parse("EXISTS"sv).is_error());
EXPECT(parse("EXISTS ("sv).is_error());
EXPECT(parse("EXISTS (SELECT"sv).is_error());
EXPECT(parse("EXISTS (SELECT)"sv).is_error());
EXPECT(parse("EXISTS (SELECT * FROM table_name"sv).is_error());
EXPECT(parse("NOT EXISTS"sv).is_error());
EXPECT(parse("NOT EXISTS ("sv).is_error());
EXPECT(parse("NOT EXISTS (SELECT"sv).is_error());
EXPECT(parse("NOT EXISTS (SELECT)"sv).is_error());
EXPECT(parse("NOT EXISTS (SELECT * FROM table_name"sv).is_error());
EXPECT(parse("("sv).is_error());
EXPECT(parse("(SELECT"sv).is_error());
EXPECT(parse("(SELECT)"sv).is_error());
EXPECT(parse("(SELECT * FROM table_name"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
@ -387,16 +387,16 @@ TEST_CASE(exists_expression)
EXPECT_EQ(exists.invert_expression(), expected_invert_expression);
};
validate("EXISTS (SELECT * FROM table_name)", false);
validate("NOT EXISTS (SELECT * FROM table_name)", true);
validate("(SELECT * FROM table_name)", false);
validate("EXISTS (SELECT * FROM table_name)"sv, false);
validate("NOT EXISTS (SELECT * FROM table_name)"sv, true);
validate("(SELECT * FROM table_name)"sv, false);
}
TEST_CASE(collate_expression)
{
EXPECT(parse("COLLATE").is_error());
EXPECT(parse("COLLATE name").is_error());
EXPECT(parse("15 COLLATE").is_error());
EXPECT(parse("COLLATE"sv).is_error());
EXPECT(parse("COLLATE name"sv).is_error());
EXPECT(parse("15 COLLATE"sv).is_error());
auto validate = [](StringView sql, StringView expected_collation_name) {
auto result = parse(sql);
@ -410,18 +410,18 @@ TEST_CASE(collate_expression)
EXPECT_EQ(collate.collation_name(), expected_collation_name);
};
validate("15 COLLATE fifteen", "FIFTEEN");
validate("(15, 16) COLLATE \"chain\"", "chain");
validate("15 COLLATE fifteen"sv, "FIFTEEN"sv);
validate("(15, 16) COLLATE \"chain\""sv, "chain"sv);
}
TEST_CASE(is_expression)
{
EXPECT(parse("IS").is_error());
EXPECT(parse("IS 1").is_error());
EXPECT(parse("1 IS").is_error());
EXPECT(parse("IS NOT").is_error());
EXPECT(parse("IS NOT 1").is_error());
EXPECT(parse("1 IS NOT").is_error());
EXPECT(parse("IS"sv).is_error());
EXPECT(parse("IS 1"sv).is_error());
EXPECT(parse("1 IS"sv).is_error());
EXPECT(parse("IS NOT"sv).is_error());
EXPECT(parse("IS NOT 1"sv).is_error());
EXPECT(parse("1 IS NOT"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
@ -436,30 +436,30 @@ TEST_CASE(is_expression)
EXPECT_EQ(is_.invert_expression(), expected_invert_expression);
};
validate("1 IS NULL", false);
validate("1 IS NOT NULL", true);
validate("1 IS NULL"sv, false);
validate("1 IS NOT NULL"sv, true);
}
TEST_CASE(match_expression)
{
HashMap<StringView, SQL::AST::MatchOperator> operators {
{ "LIKE", SQL::AST::MatchOperator::Like },
{ "GLOB", SQL::AST::MatchOperator::Glob },
{ "MATCH", SQL::AST::MatchOperator::Match },
{ "REGEXP", SQL::AST::MatchOperator::Regexp },
{ "LIKE"sv, SQL::AST::MatchOperator::Like },
{ "GLOB"sv, SQL::AST::MatchOperator::Glob },
{ "MATCH"sv, SQL::AST::MatchOperator::Match },
{ "REGEXP"sv, SQL::AST::MatchOperator::Regexp },
};
for (auto op : operators) {
EXPECT(parse(op.key).is_error());
StringBuilder builder;
builder.append("1 ");
builder.append("1 "sv);
builder.append(op.key);
EXPECT(parse(builder.build()).is_error());
builder.clear();
builder.append(op.key);
builder.append(" 1");
builder.append(" 1"sv);
EXPECT(parse(builder.build()).is_error());
}
@ -480,30 +480,30 @@ TEST_CASE(match_expression)
for (auto op : operators) {
StringBuilder builder;
builder.append("1 ");
builder.append("1 "sv);
builder.append(op.key);
builder.append(" 1");
builder.append(" 1"sv);
validate(builder.build(), op.value, false, false);
builder.clear();
builder.append("1 NOT ");
builder.append("1 NOT "sv);
builder.append(op.key);
builder.append(" 1");
builder.append(" 1"sv);
validate(builder.build(), op.value, true, false);
builder.clear();
builder.append("1 NOT ");
builder.append("1 NOT "sv);
builder.append(op.key);
builder.append(" 1 ESCAPE '+'");
builder.append(" 1 ESCAPE '+'"sv);
validate(builder.build(), op.value, true, true);
}
}
TEST_CASE(null_expression)
{
EXPECT(parse("ISNULL").is_error());
EXPECT(parse("NOTNULL").is_error());
EXPECT(parse("15 NOT").is_error());
EXPECT(parse("ISNULL"sv).is_error());
EXPECT(parse("NOTNULL"sv).is_error());
EXPECT(parse("15 NOT"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
@ -516,21 +516,21 @@ TEST_CASE(null_expression)
EXPECT_EQ(null.invert_expression(), expected_invert_expression);
};
validate("15 ISNULL", false);
validate("15 NOTNULL", true);
validate("15 NOT NULL", true);
validate("15 ISNULL"sv, false);
validate("15 NOTNULL"sv, true);
validate("15 NOT NULL"sv, true);
}
TEST_CASE(between_expression)
{
EXPECT(parse("BETWEEN").is_error());
EXPECT(parse("NOT BETWEEN").is_error());
EXPECT(parse("BETWEEN 10 AND 20").is_error());
EXPECT(parse("NOT BETWEEN 10 AND 20").is_error());
EXPECT(parse("15 BETWEEN 10").is_error());
EXPECT(parse("15 BETWEEN 10 AND").is_error());
EXPECT(parse("15 BETWEEN AND 20").is_error());
EXPECT(parse("15 BETWEEN 10 OR 20").is_error());
EXPECT(parse("BETWEEN"sv).is_error());
EXPECT(parse("NOT BETWEEN"sv).is_error());
EXPECT(parse("BETWEEN 10 AND 20"sv).is_error());
EXPECT(parse("NOT BETWEEN 10 AND 20"sv).is_error());
EXPECT(parse("15 BETWEEN 10"sv).is_error());
EXPECT(parse("15 BETWEEN 10 AND"sv).is_error());
EXPECT(parse("15 BETWEEN AND 20"sv).is_error());
EXPECT(parse("15 BETWEEN 10 OR 20"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
@ -546,16 +546,16 @@ TEST_CASE(between_expression)
EXPECT_EQ(between.invert_expression(), expected_invert_expression);
};
validate("15 BETWEEN 10 AND 20", false);
validate("15 NOT BETWEEN 10 AND 20", true);
validate("15 BETWEEN 10 AND 20"sv, false);
validate("15 NOT BETWEEN 10 AND 20"sv, true);
}
TEST_CASE(in_table_expression)
{
EXPECT(parse("IN").is_error());
EXPECT(parse("IN table_name").is_error());
EXPECT(parse("NOT IN").is_error());
EXPECT(parse("NOT IN table_name").is_error());
EXPECT(parse("IN"sv).is_error());
EXPECT(parse("IN table_name"sv).is_error());
EXPECT(parse("NOT IN"sv).is_error());
EXPECT(parse("NOT IN table_name"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, bool expected_invert_expression) {
auto result = parse(sql);
@ -571,17 +571,17 @@ TEST_CASE(in_table_expression)
EXPECT_EQ(in.invert_expression(), expected_invert_expression);
};
validate("15 IN table_name", {}, "TABLE_NAME", false);
validate("15 IN schema_name.table_name", "SCHEMA_NAME", "TABLE_NAME", false);
validate("15 IN table_name"sv, {}, "TABLE_NAME"sv, false);
validate("15 IN schema_name.table_name"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, false);
validate("15 NOT IN table_name", {}, "TABLE_NAME", true);
validate("15 NOT IN schema_name.table_name", "SCHEMA_NAME", "TABLE_NAME", true);
validate("15 NOT IN table_name"sv, {}, "TABLE_NAME"sv, true);
validate("15 NOT IN schema_name.table_name"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, true);
}
TEST_CASE(in_chained_expression)
{
EXPECT(parse("IN ()").is_error());
EXPECT(parse("NOT IN ()").is_error());
EXPECT(parse("IN ()"sv).is_error());
EXPECT(parse("NOT IN ()"sv).is_error());
auto validate = [](StringView sql, size_t expected_chain_size, bool expected_invert_expression) {
auto result = parse(sql);
@ -599,21 +599,21 @@ TEST_CASE(in_chained_expression)
EXPECT(!is<SQL::AST::ErrorExpression>(chained_expression));
};
validate("15 IN ()", 0, false);
validate("15 IN (15)", 1, false);
validate("15 IN (15, 16)", 2, false);
validate("15 IN ()"sv, 0, false);
validate("15 IN (15)"sv, 1, false);
validate("15 IN (15, 16)"sv, 2, false);
validate("15 NOT IN ()", 0, true);
validate("15 NOT IN (15)", 1, true);
validate("15 NOT IN (15, 16)", 2, true);
validate("15 NOT IN ()"sv, 0, true);
validate("15 NOT IN (15)"sv, 1, true);
validate("15 NOT IN (15, 16)"sv, 2, true);
}
TEST_CASE(in_selection_expression)
{
EXPECT(parse("IN (SELECT)").is_error());
EXPECT(parse("IN (SELECT * FROM table_name, SELECT * FROM table_name);").is_error());
EXPECT(parse("NOT IN (SELECT)").is_error());
EXPECT(parse("NOT IN (SELECT * FROM table_name, SELECT * FROM table_name);").is_error());
EXPECT(parse("IN (SELECT)"sv).is_error());
EXPECT(parse("IN (SELECT * FROM table_name, SELECT * FROM table_name);"sv).is_error());
EXPECT(parse("NOT IN (SELECT)"sv).is_error());
EXPECT(parse("NOT IN (SELECT * FROM table_name, SELECT * FROM table_name);"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
@ -627,8 +627,8 @@ TEST_CASE(in_selection_expression)
EXPECT_EQ(in.invert_expression(), expected_invert_expression);
};
validate("15 IN (SELECT * FROM table_name)", false);
validate("15 NOT IN (SELECT * FROM table_name)", true);
validate("15 IN (SELECT * FROM table_name)"sv, false);
validate("15 NOT IN (SELECT * FROM table_name)"sv, true);
}
TEST_CASE(expression_tree_depth_limit)

488
Tests/LibSQL/TestSqlStatementParser.cpp
View file

@ -37,27 +37,27 @@ ParseResult parse(StringView sql)
TEST_CASE(create_table)
{
EXPECT(parse("CREATE TABLE").is_error());
EXPECT(parse("CREATE TABLE test").is_error());
EXPECT(parse("CREATE TABLE test ()").is_error());
EXPECT(parse("CREATE TABLE test ();").is_error());
EXPECT(parse("CREATE TABLE test ( column1 ").is_error());
EXPECT(parse("CREATE TABLE test ( column1 )").is_error());
EXPECT(parse("CREATE TABLE IF test ( column1 );").is_error());
EXPECT(parse("CREATE TABLE IF NOT test ( column1 );").is_error());
EXPECT(parse("CREATE TABLE AS;").is_error());
EXPECT(parse("CREATE TABLE AS SELECT;").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar()").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(abc)").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(123 )").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(123, )").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(123, ) )").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(.) )").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(.abc) )").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(0x) )").is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(0xzzz) )").is_error());
EXPECT(parse("CREATE TABLE test ( column1 int ) AS SELECT * FROM table_name;").is_error());
EXPECT(parse("CREATE TABLE test AS SELECT * FROM table_name ( column1 int ) ;").is_error());
EXPECT(parse("CREATE TABLE"sv).is_error());
EXPECT(parse("CREATE TABLE test"sv).is_error());
EXPECT(parse("CREATE TABLE test ()"sv).is_error());
EXPECT(parse("CREATE TABLE test ();"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 "sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 )"sv).is_error());
EXPECT(parse("CREATE TABLE IF test ( column1 );"sv).is_error());
EXPECT(parse("CREATE TABLE IF NOT test ( column1 );"sv).is_error());
EXPECT(parse("CREATE TABLE AS;"sv).is_error());
EXPECT(parse("CREATE TABLE AS SELECT;"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar()"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(abc)"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(123 )"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(123, )"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(123, ) )"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(.) )"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(.abc) )"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(0x) )"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 varchar(0xzzz) )"sv).is_error());
EXPECT(parse("CREATE TABLE test ( column1 int ) AS SELECT * FROM table_name;"sv).is_error());
EXPECT(parse("CREATE TABLE test AS SELECT * FROM table_name ( column1 int ) ;"sv).is_error());
struct Column {
StringView name;
@ -109,42 +109,42 @@ TEST_CASE(create_table)
}
};
validate("CREATE TABLE test ( column1 );", {}, "TEST", { { "COLUMN1", "BLOB" } });
validate("Create Table test ( column1 );", {}, "TEST", { { "COLUMN1", "BLOB" } });
validate(R"(CREATE TABLE "test" ( "column1" );)", {}, "test", { { "column1", "BLOB" } });
validate(R"(CREATE TABLE "te""st" ( "co""lumn1" );)", {}, "te\"st", { { "co\"lumn1", "BLOB" } });
validate("CREATE TABLE schema_name.test ( column1 );", "SCHEMA_NAME", "TEST", { { "COLUMN1", "BLOB" } });
validate("CREATE TABLE \"schema\".test ( column1 );", "schema", "TEST", { { "COLUMN1", "BLOB" } });
validate("CREATE TEMP TABLE test ( column1 );", {}, "TEST", { { "COLUMN1", "BLOB" } }, true, true);
validate("CREATE TEMPORARY TABLE test ( column1 );", {}, "TEST", { { "COLUMN1", "BLOB" } }, true, true);
validate("CREATE TABLE IF NOT EXISTS test ( column1 );", {}, "TEST", { { "COLUMN1", "BLOB" } }, false, false);
validate("CREATE TABLE test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } });
validate("Create Table test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } });
validate(R"(CREATE TABLE "test" ( "column1" );)"sv, {}, "test"sv, { { "column1"sv, "BLOB"sv } });
validate(R"(CREATE TABLE "te""st" ( "co""lumn1" );)"sv, {}, "te\"st"sv, { { "co\"lumn1"sv, "BLOB"sv } });
validate("CREATE TABLE schema_name.test ( column1 );"sv, "SCHEMA_NAME"sv, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } });
validate("CREATE TABLE \"schema\".test ( column1 );"sv, "schema"sv, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } });
validate("CREATE TEMP TABLE test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } }, true, true);
validate("CREATE TEMPORARY TABLE test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } }, true, true);
validate("CREATE TABLE IF NOT EXISTS test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } }, false, false);
validate("CREATE TABLE test AS SELECT * FROM table_name;", {}, "TEST", {});
validate("CREATE TABLE test AS SELECT * FROM table_name;"sv, {}, "TEST"sv, {});
validate("CREATE TABLE test ( column1 int );", {}, "TEST", { { "COLUMN1", "INT" } });
validate("CREATE TABLE test ( column1 varchar );", {}, "TEST", { { "COLUMN1", "VARCHAR" } });
validate("CREATE TABLE test ( column1 varchar(255) );", {}, "TEST", { { "COLUMN1", "VARCHAR", { 255 } } });
validate("CREATE TABLE test ( column1 varchar(255, 123) );", {}, "TEST", { { "COLUMN1", "VARCHAR", { 255, 123 } } });
validate("CREATE TABLE test ( column1 varchar(255, -123) );", {}, "TEST", { { "COLUMN1", "VARCHAR", { 255, -123 } } });
validate("CREATE TABLE test ( column1 varchar(0xff) );", {}, "TEST", { { "COLUMN1", "VARCHAR", { 255 } } });
validate("CREATE TABLE test ( column1 varchar(3.14) );", {}, "TEST", { { "COLUMN1", "VARCHAR", { 3.14 } } });
validate("CREATE TABLE test ( column1 varchar(1e3) );", {}, "TEST", { { "COLUMN1", "VARCHAR", { 1000 } } });
validate("CREATE TABLE test ( column1 int );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "INT"sv } });
validate("CREATE TABLE test ( column1 varchar );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv } });
validate("CREATE TABLE test ( column1 varchar(255) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 255 } } });
validate("CREATE TABLE test ( column1 varchar(255, 123) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 255, 123 } } });
validate("CREATE TABLE test ( column1 varchar(255, -123) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 255, -123 } } });
validate("CREATE TABLE test ( column1 varchar(0xff) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 255 } } });
validate("CREATE TABLE test ( column1 varchar(3.14) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 3.14 } } });
validate("CREATE TABLE test ( column1 varchar(1e3) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 1000 } } });
}
TEST_CASE(alter_table)
{
// This test case only contains common error cases of the AlterTable subclasses.
EXPECT(parse("ALTER").is_error());
EXPECT(parse("ALTER TABLE").is_error());
EXPECT(parse("ALTER TABLE table_name").is_error());
EXPECT(parse("ALTER TABLE table_name;").is_error());
EXPECT(parse("ALTER"sv).is_error());
EXPECT(parse("ALTER TABLE"sv).is_error());
EXPECT(parse("ALTER TABLE table_name"sv).is_error());
EXPECT(parse("ALTER TABLE table_name;"sv).is_error());
}
TEST_CASE(alter_table_rename_table)
{
EXPECT(parse("ALTER TABLE table_name RENAME").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME TO").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME TO new_table").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME TO"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME TO new_table"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_new_table) {
auto result = parse(sql);
@ -159,20 +159,20 @@ TEST_CASE(alter_table_rename_table)
EXPECT_EQ(alter.new_table_name(), expected_new_table);
};
validate("ALTER TABLE table_name RENAME TO new_table;", {}, "TABLE_NAME", "NEW_TABLE");
validate("ALTER TABLE schema_name.table_name RENAME TO new_table;", "SCHEMA_NAME", "TABLE_NAME", "NEW_TABLE");
validate("ALTER TABLE table_name RENAME TO new_table;"sv, {}, "TABLE_NAME"sv, "NEW_TABLE"sv);
validate("ALTER TABLE schema_name.table_name RENAME TO new_table;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "NEW_TABLE"sv);
}
TEST_CASE(alter_table_rename_column)
{
EXPECT(parse("ALTER TABLE table_name RENAME").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME COLUMN").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name TO").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name TO new_column").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME column_name").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME column_name TO").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME column_name TO new_column").is_error());
EXPECT(parse("ALTER TABLE table_name RENAME"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME COLUMN"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name TO"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name TO new_column"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME column_name"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME column_name TO"sv).is_error());
EXPECT(parse("ALTER TABLE table_name RENAME column_name TO new_column"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column, StringView expected_new_column) {
auto result = parse(sql);
@ -188,17 +188,17 @@ TEST_CASE(alter_table_rename_column)
EXPECT_EQ(alter.new_column_name(), expected_new_column);
};
validate("ALTER TABLE table_name RENAME column_name TO new_column;", {}, "TABLE_NAME", "COLUMN_NAME", "NEW_COLUMN");
validate("ALTER TABLE table_name RENAME COLUMN column_name TO new_column;", {}, "TABLE_NAME", "COLUMN_NAME", "NEW_COLUMN");
validate("ALTER TABLE schema_name.table_name RENAME column_name TO new_column;", "SCHEMA_NAME", "TABLE_NAME", "COLUMN_NAME", "NEW_COLUMN");
validate("ALTER TABLE schema_name.table_name RENAME COLUMN column_name TO new_column;", "SCHEMA_NAME", "TABLE_NAME", "COLUMN_NAME", "NEW_COLUMN");
validate("ALTER TABLE table_name RENAME column_name TO new_column;"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv, "NEW_COLUMN"sv);
validate("ALTER TABLE table_name RENAME COLUMN column_name TO new_column;"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv, "NEW_COLUMN"sv);
validate("ALTER TABLE schema_name.table_name RENAME column_name TO new_column;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv, "NEW_COLUMN"sv);
validate("ALTER TABLE schema_name.table_name RENAME COLUMN column_name TO new_column;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv, "NEW_COLUMN"sv);
}
TEST_CASE(alter_table_add_column)
{
EXPECT(parse("ALTER TABLE table_name ADD").is_error());
EXPECT(parse("ALTER TABLE table_name ADD COLUMN").is_error());
EXPECT(parse("ALTER TABLE table_name ADD COLUMN column_name").is_error());
EXPECT(parse("ALTER TABLE table_name ADD"sv).is_error());
EXPECT(parse("ALTER TABLE table_name ADD COLUMN"sv).is_error());
EXPECT(parse("ALTER TABLE table_name ADD COLUMN column_name"sv).is_error());
struct Column {
StringView name;
@ -233,25 +233,25 @@ TEST_CASE(alter_table_add_column)
}
};
validate("ALTER TABLE test ADD column1;", {}, "TEST", { "COLUMN1", "BLOB" });
validate("ALTER TABLE test ADD column1 int;", {}, "TEST", { "COLUMN1", "INT" });
validate("ALTER TABLE test ADD column1 varchar;", {}, "TEST", { "COLUMN1", "VARCHAR" });
validate("ALTER TABLE test ADD column1 varchar(255);", {}, "TEST", { "COLUMN1", "VARCHAR", { 255 } });
validate("ALTER TABLE test ADD column1 varchar(255, 123);", {}, "TEST", { "COLUMN1", "VARCHAR", { 255, 123 } });
validate("ALTER TABLE test ADD column1;"sv, {}, "TEST"sv, { "COLUMN1"sv, "BLOB"sv });
validate("ALTER TABLE test ADD column1 int;"sv, {}, "TEST"sv, { "COLUMN1"sv, "INT"sv });
validate("ALTER TABLE test ADD column1 varchar;"sv, {}, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv });
validate("ALTER TABLE test ADD column1 varchar(255);"sv, {}, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv, { 255 } });
validate("ALTER TABLE test ADD column1 varchar(255, 123);"sv, {}, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv, { 255, 123 } });
validate("ALTER TABLE schema_name.test ADD COLUMN column1;", "SCHEMA_NAME", "TEST", { "COLUMN1", "BLOB" });
validate("ALTER TABLE schema_name.test ADD COLUMN column1 int;", "SCHEMA_NAME", "TEST", { "COLUMN1", "INT" });
validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar;", "SCHEMA_NAME", "TEST", { "COLUMN1", "VARCHAR" });
validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar(255);", "SCHEMA_NAME", "TEST", { "COLUMN1", "VARCHAR", { 255 } });
validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar(255, 123);", "SCHEMA_NAME", "TEST", { "COLUMN1", "VARCHAR", { 255, 123 } });
validate("ALTER TABLE schema_name.test ADD COLUMN column1;"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "BLOB"sv });
validate("ALTER TABLE schema_name.test ADD COLUMN column1 int;"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "INT"sv });
validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar;"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv });
validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar(255);"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv, { 255 } });
validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar(255, 123);"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv, { 255, 123 } });
}
TEST_CASE(alter_table_drop_column)
{
EXPECT(parse("ALTER TABLE table_name DROP").is_error());
EXPECT(parse("ALTER TABLE table_name DROP COLUMN").is_error());
EXPECT(parse("ALTER TABLE table_name DROP column_name").is_error());
EXPECT(parse("ALTER TABLE table_name DROP COLUMN column_name").is_error());
EXPECT(parse("ALTER TABLE table_name DROP"sv).is_error());
EXPECT(parse("ALTER TABLE table_name DROP COLUMN"sv).is_error());
EXPECT(parse("ALTER TABLE table_name DROP column_name"sv).is_error());
EXPECT(parse("ALTER TABLE table_name DROP COLUMN column_name"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column) {
auto result = parse(sql);
@ -266,18 +266,18 @@ TEST_CASE(alter_table_drop_column)
EXPECT_EQ(alter.column_name(), expected_column);
};
validate("ALTER TABLE table_name DROP column_name;", {}, "TABLE_NAME", "COLUMN_NAME");
validate("ALTER TABLE table_name DROP COLUMN column_name;", {}, "TABLE_NAME", "COLUMN_NAME");
validate("ALTER TABLE schema_name.table_name DROP column_name;", "SCHEMA_NAME", "TABLE_NAME", "COLUMN_NAME");
validate("ALTER TABLE schema_name.table_name DROP COLUMN column_name;", "SCHEMA_NAME", "TABLE_NAME", "COLUMN_NAME");
validate("ALTER TABLE table_name DROP column_name;"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv);
validate("ALTER TABLE table_name DROP COLUMN column_name;"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv);
validate("ALTER TABLE schema_name.table_name DROP column_name;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv);
validate("ALTER TABLE schema_name.table_name DROP COLUMN column_name;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv);
}
TEST_CASE(drop_table)
{
EXPECT(parse("DROP").is_error());
EXPECT(parse("DROP TABLE").is_error());
EXPECT(parse("DROP TABLE test").is_error());
EXPECT(parse("DROP TABLE IF test;").is_error());
EXPECT(parse("DROP"sv).is_error());
EXPECT(parse("DROP TABLE"sv).is_error());
EXPECT(parse("DROP TABLE test"sv).is_error());
EXPECT(parse("DROP TABLE IF test;"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, bool expected_is_error_if_table_does_not_exist = true) {
auto result = parse(sql);
@ -292,25 +292,25 @@ TEST_CASE(drop_table)
EXPECT_EQ(table.is_error_if_table_does_not_exist(), expected_is_error_if_table_does_not_exist);
};
validate("DROP TABLE test;", {}, "TEST");
validate("DROP TABLE schema_name.test;", "SCHEMA_NAME", "TEST");
validate("DROP TABLE IF EXISTS test;", {}, "TEST", false);
validate("DROP TABLE test;"sv, {}, "TEST"sv);
validate("DROP TABLE schema_name.test;"sv, "SCHEMA_NAME"sv, "TEST"sv);
validate("DROP TABLE IF EXISTS test;"sv, {}, "TEST"sv, false);
}
TEST_CASE(insert)
{
EXPECT(parse("INSERT").is_error());
EXPECT(parse("INSERT INTO").is_error());
EXPECT(parse("INSERT INTO table_name").is_error());
EXPECT(parse("INSERT INTO table_name (column_name)").is_error());
EXPECT(parse("INSERT INTO table_name (column_name, ) DEFAULT VALUES;").is_error());
EXPECT(parse("INSERT INTO table_name VALUES").is_error());
EXPECT(parse("INSERT INTO table_name VALUES ();").is_error());
EXPECT(parse("INSERT INTO table_name VALUES (1)").is_error());
EXPECT(parse("INSERT INTO table_name SELECT").is_error());
EXPECT(parse("INSERT INTO table_name SELECT * from table_name").is_error());
EXPECT(parse("INSERT OR INTO table_name DEFAULT VALUES;").is_error());
EXPECT(parse("INSERT OR foo INTO table_name DEFAULT VALUES;").is_error());
EXPECT(parse("INSERT"sv).is_error());
EXPECT(parse("INSERT INTO"sv).is_error());
EXPECT(parse("INSERT INTO table_name"sv).is_error());
EXPECT(parse("INSERT INTO table_name (column_name)"sv).is_error());
EXPECT(parse("INSERT INTO table_name (column_name, ) DEFAULT VALUES;"sv).is_error());
EXPECT(parse("INSERT INTO table_name VALUES"sv).is_error());
EXPECT(parse("INSERT INTO table_name VALUES ();"sv).is_error());
EXPECT(parse("INSERT INTO table_name VALUES (1)"sv).is_error());
EXPECT(parse("INSERT INTO table_name SELECT"sv).is_error());
EXPECT(parse("INSERT INTO table_name SELECT * from table_name"sv).is_error());
EXPECT(parse("INSERT OR INTO table_name DEFAULT VALUES;"sv).is_error());
EXPECT(parse("INSERT OR foo INTO table_name DEFAULT VALUES;"sv).is_error());
auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<StringView> expected_column_names, Vector<size_t> expected_chain_sizes, bool expect_select_statement) {
auto result = parse(sql);
@ -349,48 +349,48 @@ TEST_CASE(insert)
EXPECT_EQ(insert.default_values(), expected_chain_sizes.is_empty() && !expect_select_statement);
};
validate("INSERT OR ABORT INTO table_name DEFAULT VALUES;", SQL::AST::ConflictResolution::Abort, {}, "TABLE_NAME", {}, {}, {}, false);
validate("INSERT OR FAIL INTO table_name DEFAULT VALUES;", SQL::AST::ConflictResolution::Fail, {}, "TABLE_NAME", {}, {}, {}, false);
validate("INSERT OR IGNORE INTO table_name DEFAULT VALUES;", SQL::AST::ConflictResolution::Ignore, {}, "TABLE_NAME", {}, {}, {}, false);
validate("INSERT OR REPLACE INTO table_name DEFAULT VALUES;", SQL::AST::ConflictResolution::Replace, {}, "TABLE_NAME", {}, {}, {}, false);
validate("INSERT OR ROLLBACK INTO table_name DEFAULT VALUES;", SQL::AST::ConflictResolution::Rollback, {}, "TABLE_NAME", {}, {}, {}, false);
validate("INSERT OR ABORT INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Abort, {}, "TABLE_NAME"sv, {}, {}, {}, false);
validate("INSERT OR FAIL INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Fail, {}, "TABLE_NAME"sv, {}, {}, {}, false);
validate("INSERT OR IGNORE INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Ignore, {}, "TABLE_NAME"sv, {}, {}, {}, false);
validate("INSERT OR REPLACE INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Replace, {}, "TABLE_NAME"sv, {}, {}, {}, false);
validate("INSERT OR ROLLBACK INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Rollback, {}, "TABLE_NAME"sv, {}, {}, {}, false);
auto resolution = SQL::AST::ConflictResolution::Abort;
validate("INSERT INTO table_name DEFAULT VALUES;", resolution, {}, "TABLE_NAME", {}, {}, {}, false);
validate("INSERT INTO schema_name.table_name DEFAULT VALUES;", resolution, "SCHEMA_NAME", "TABLE_NAME", {}, {}, {}, false);
validate("INSERT INTO table_name AS foo DEFAULT VALUES;", resolution, {}, "TABLE_NAME", "FOO", {}, {}, false);
validate("INSERT INTO table_name DEFAULT VALUES;"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, {}, false);
validate("INSERT INTO schema_name.table_name DEFAULT VALUES;"sv, resolution, "SCHEMA_NAME"sv, "TABLE_NAME"sv, {}, {}, {}, false);
validate("INSERT INTO table_name AS foo DEFAULT VALUES;"sv, resolution, {}, "TABLE_NAME"sv, "FOO"sv, {}, {}, false);
validate("INSERT INTO table_name (column_name) DEFAULT VALUES;", resolution, {}, "TABLE_NAME", {}, { "COLUMN_NAME" }, {}, false);
validate("INSERT INTO table_name (column1, column2) DEFAULT VALUES;", resolution, {}, "TABLE_NAME", {}, { "COLUMN1", "COLUMN2" }, {}, false);
validate("INSERT INTO table_name (column_name) DEFAULT VALUES;"sv, resolution, {}, "TABLE_NAME"sv, {}, { "COLUMN_NAME"sv }, {}, false);
validate("INSERT INTO table_name (column1, column2) DEFAULT VALUES;"sv, resolution, {}, "TABLE_NAME"sv, {}, { "COLUMN1"sv, "COLUMN2"sv }, {}, false);
validate("INSERT INTO table_name VALUES (1);", resolution, {}, "TABLE_NAME", {}, {}, { 1 }, false);
validate("INSERT INTO table_name VALUES (1, 2);", resolution, {}, "TABLE_NAME", {}, {}, { 2 }, false);
validate("INSERT INTO table_name VALUES (1, 2), (3, 4, 5);", resolution, {}, "TABLE_NAME", {}, {}, { 2, 3 }, false);
validate("INSERT INTO table_name VALUES (1);"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, { 1 }, false);
validate("INSERT INTO table_name VALUES (1, 2);"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, { 2 }, false);
validate("INSERT INTO table_name VALUES (1, 2), (3, 4, 5);"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, { 2, 3 }, false);
validate("INSERT INTO table_name SELECT * FROM table_name;", resolution, {}, "TABLE_NAME", {}, {}, {}, true);
validate("INSERT INTO table_name SELECT * FROM table_name;"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, {}, true);
}
TEST_CASE(update)
{
EXPECT(parse("UPDATE").is_error());
EXPECT(parse("UPDATE table_name").is_error());
EXPECT(parse("UPDATE table_name SET").is_error());
EXPECT(parse("UPDATE table_name SET column_name").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4, ;").is_error());
EXPECT(parse("UPDATE table_name SET (column_name)=4").is_error());
EXPECT(parse("UPDATE table_name SET (column_name)=4, ;").is_error());
EXPECT(parse("UPDATE table_name SET (column_name, )=4;").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 FROM").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 FROM table_name").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 WHERE").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 WHERE 1==1").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING *").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING column_name").is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING column_name AS").is_error());
EXPECT(parse("UPDATE OR table_name SET column_name=4;").is_error());
EXPECT(parse("UPDATE OR foo table_name SET column_name=4;").is_error());
EXPECT(parse("UPDATE"sv).is_error());
EXPECT(parse("UPDATE table_name"sv).is_error());
EXPECT(parse("UPDATE table_name SET"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4, ;"sv).is_error());
EXPECT(parse("UPDATE table_name SET (column_name)=4"sv).is_error());
EXPECT(parse("UPDATE table_name SET (column_name)=4, ;"sv).is_error());
EXPECT(parse("UPDATE table_name SET (column_name, )=4;"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 FROM"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 FROM table_name"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 WHERE"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 WHERE 1==1"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING *"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING column_name"sv).is_error());
EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING column_name AS"sv).is_error());
EXPECT(parse("UPDATE OR table_name SET column_name=4;"sv).is_error());
EXPECT(parse("UPDATE OR foo table_name SET column_name=4;"sv).is_error());
auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<Vector<String>> expected_update_columns, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
auto result = parse(sql);
@ -440,41 +440,41 @@ TEST_CASE(update)
};
Vector<Vector<String>> update_columns { { "COLUMN_NAME" } };
validate("UPDATE OR ABORT table_name SET column_name=1;", SQL::AST::ConflictResolution::Abort, {}, "TABLE_NAME", {}, update_columns, false, false, {});
validate("UPDATE OR FAIL table_name SET column_name=1;", SQL::AST::ConflictResolution::Fail, {}, "TABLE_NAME", {}, update_columns, false, false, {});
validate("UPDATE OR IGNORE table_name SET column_name=1;", SQL::AST::ConflictResolution::Ignore, {}, "TABLE_NAME", {}, update_columns, false, false, {});
validate("UPDATE OR REPLACE table_name SET column_name=1;", SQL::AST::ConflictResolution::Replace, {}, "TABLE_NAME", {}, update_columns, false, false, {});
validate("UPDATE OR ROLLBACK table_name SET column_name=1;", SQL::AST::ConflictResolution::Rollback, {}, "TABLE_NAME", {}, update_columns, false, false, {});
validate("UPDATE OR ABORT table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Abort, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
validate("UPDATE OR FAIL table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Fail, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
validate("UPDATE OR IGNORE table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Ignore, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
validate("UPDATE OR REPLACE table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Replace, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
validate("UPDATE OR ROLLBACK table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Rollback, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
auto resolution = SQL::AST::ConflictResolution::Abort;
validate("UPDATE table_name SET column_name=1;", resolution, {}, "TABLE_NAME", {}, update_columns, false, false, {});
validate("UPDATE schema_name.table_name SET column_name=1;", resolution, "SCHEMA_NAME", "TABLE_NAME", {}, update_columns, false, false, {});
validate("UPDATE table_name AS foo SET column_name=1;", resolution, {}, "TABLE_NAME", "FOO", update_columns, false, false, {});
validate("UPDATE table_name SET column_name=1;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
validate("UPDATE schema_name.table_name SET column_name=1;"sv, resolution, "SCHEMA_NAME"sv, "TABLE_NAME"sv, {}, update_columns, false, false, {});
validate("UPDATE table_name AS foo SET column_name=1;"sv, resolution, {}, "TABLE_NAME"sv, "FOO"sv, update_columns, false, false, {});
validate("UPDATE table_name SET column_name=1;", resolution, {}, "TABLE_NAME", {}, { { "COLUMN_NAME" } }, false, false, {});
validate("UPDATE table_name SET column1=1, column2=2;", resolution, {}, "TABLE_NAME", {}, { { "COLUMN1" }, { "COLUMN2" } }, false, false, {});
validate("UPDATE table_name SET (column1, column2)=1, column3=2;", resolution, {}, "TABLE_NAME", {}, { { "COLUMN1", "COLUMN2" }, { "COLUMN3" } }, false, false, {});
validate("UPDATE table_name SET column_name=1;"sv, resolution, {}, "TABLE_NAME"sv, {}, { { "COLUMN_NAME"sv } }, false, false, {});
validate("UPDATE table_name SET column1=1, column2=2;"sv, resolution, {}, "TABLE_NAME"sv, {}, { { "COLUMN1"sv }, { "COLUMN2"sv } }, false, false, {});
validate("UPDATE table_name SET (column1, column2)=1, column3=2;"sv, resolution, {}, "TABLE_NAME"sv, {}, { { "COLUMN1"sv, "COLUMN2"sv }, { "COLUMN3"sv } }, false, false, {});
validate("UPDATE table_name SET column_name=1 WHERE 1==1;", resolution, {}, "TABLE_NAME", {}, update_columns, true, false, {});
validate("UPDATE table_name SET column_name=1 WHERE 1==1;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, true, false, {});
validate("UPDATE table_name SET column_name=1 RETURNING *;", resolution, {}, "TABLE_NAME", {}, update_columns, false, true, {});
validate("UPDATE table_name SET column_name=1 RETURNING column_name;", resolution, {}, "TABLE_NAME", {}, update_columns, false, true, { {} });
validate("UPDATE table_name SET column_name=1 RETURNING column_name AS alias;", resolution, {}, "TABLE_NAME", {}, update_columns, false, true, { "ALIAS" });
validate("UPDATE table_name SET column_name=1 RETURNING column1 AS alias1, column2 AS alias2;", resolution, {}, "TABLE_NAME", {}, update_columns, false, true, { "ALIAS1", "ALIAS2" });
validate("UPDATE table_name SET column_name=1 RETURNING *;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, true, {});
validate("UPDATE table_name SET column_name=1 RETURNING column_name;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, true, { {} });
validate("UPDATE table_name SET column_name=1 RETURNING column_name AS alias;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, true, { "ALIAS"sv });
validate("UPDATE table_name SET column_name=1 RETURNING column1 AS alias1, column2 AS alias2;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, true, { "ALIAS1"sv, "ALIAS2"sv });
}
TEST_CASE(delete_)
{
EXPECT(parse("DELETE").is_error());
EXPECT(parse("DELETE FROM").is_error());
EXPECT(parse("DELETE FROM table_name").is_error());
EXPECT(parse("DELETE FROM table_name WHERE").is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15").is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING").is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING *").is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING column_name").is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING column_name AS;").is_error());
EXPECT(parse("DELETE FROM table_name WHERE (');").is_error());
EXPECT(parse("DELETE"sv).is_error());
EXPECT(parse("DELETE FROM"sv).is_error());
EXPECT(parse("DELETE FROM table_name"sv).is_error());
EXPECT(parse("DELETE FROM table_name WHERE"sv).is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15"sv).is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING"sv).is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING *"sv).is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING column_name"sv).is_error());
EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING column_name AS;"sv).is_error());
EXPECT(parse("DELETE FROM table_name WHERE (');"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_alias, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
auto result = parse(sql);
@ -510,50 +510,50 @@ TEST_CASE(delete_)
}
};
validate("DELETE FROM table_name;", {}, "TABLE_NAME", {}, false, false, {});
validate("DELETE FROM schema_name.table_name;", "SCHEMA_NAME", "TABLE_NAME", {}, false, false, {});
validate("DELETE FROM schema_name.table_name AS alias;", "SCHEMA_NAME", "TABLE_NAME", "ALIAS", false, false, {});
validate("DELETE FROM table_name WHERE (1 == 1);", {}, "TABLE_NAME", {}, true, false, {});
validate("DELETE FROM table_name RETURNING *;", {}, "TABLE_NAME", {}, false, true, {});
validate("DELETE FROM table_name RETURNING column_name;", {}, "TABLE_NAME", {}, false, true, { {} });
validate("DELETE FROM table_name RETURNING column_name AS alias;", {}, "TABLE_NAME", {}, false, true, { "ALIAS" });
validate("DELETE FROM table_name RETURNING column1 AS alias1, column2 AS alias2;", {}, "TABLE_NAME", {}, false, true, { "ALIAS1", "ALIAS2" });
validate("DELETE FROM table_name;"sv, {}, "TABLE_NAME"sv, {}, false, false, {});
validate("DELETE FROM schema_name.table_name;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, {}, false, false, {});
validate("DELETE FROM schema_name.table_name AS alias;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "ALIAS"sv, false, false, {});
validate("DELETE FROM table_name WHERE (1 == 1);"sv, {}, "TABLE_NAME"sv, {}, true, false, {});
validate("DELETE FROM table_name RETURNING *;"sv, {}, "TABLE_NAME"sv, {}, false, true, {});
validate("DELETE FROM table_name RETURNING column_name;"sv, {}, "TABLE_NAME"sv, {}, false, true, { {} });
validate("DELETE FROM table_name RETURNING column_name AS alias;"sv, {}, "TABLE_NAME"sv, {}, false, true, { "ALIAS"sv });
validate("DELETE FROM table_name RETURNING column1 AS alias1, column2 AS alias2;"sv, {}, "TABLE_NAME"sv, {}, false, true, { "ALIAS1"sv, "ALIAS2"sv });
}
TEST_CASE(select)
{
EXPECT(parse("SELECT").is_error());
EXPECT(parse("SELECT;").is_error());
EXPECT(parse("SELECT DISTINCT;").is_error());
EXPECT(parse("SELECT ALL;").is_error());
EXPECT(parse("SELECT *").is_error());
EXPECT(parse("SELECT * FROM;").is_error());
EXPECT(parse("SELECT table_name. FROM table_name;").is_error());
EXPECT(parse("SELECT column_name AS FROM table_name;").is_error());
EXPECT(parse("SELECT * FROM (").is_error());
EXPECT(parse("SELECT * FROM ()").is_error());
EXPECT(parse("SELECT * FROM ();").is_error());
EXPECT(parse("SELECT * FROM (table_name1)").is_error());
EXPECT(parse("SELECT * FROM (table_name1, )").is_error());
EXPECT(parse("SELECT * FROM (table_name1, table_name2)").is_error());
EXPECT(parse("SELECT * FROM table_name").is_error());
EXPECT(parse("SELECT * FROM table_name AS;").is_error());
EXPECT(parse("SELECT * FROM table_name WHERE;").is_error());
EXPECT(parse("SELECT * FROM table_name WHERE 1 ==1").is_error());
EXPECT(parse("SELECT * FROM table_name GROUP;").is_error());
EXPECT(parse("SELECT * FROM table_name GROUP BY;").is_error());
EXPECT(parse("SELECT * FROM table_name GROUP BY column_name").is_error());
EXPECT(parse("SELECT * FROM table_name ORDER:").is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name").is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name COLLATE:").is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name COLLATE collation").is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name NULLS;").is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name NULLS SECOND;").is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT;").is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT 12").is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT 12 OFFSET;").is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT 12 OFFSET 15").is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT 15, 16;").is_error());
EXPECT(parse("SELECT"sv).is_error());
EXPECT(parse("SELECT;"sv).is_error());
EXPECT(parse("SELECT DISTINCT;"sv).is_error());
EXPECT(parse("SELECT ALL;"sv).is_error());
EXPECT(parse("SELECT *"sv).is_error());
EXPECT(parse("SELECT * FROM;"sv).is_error());
EXPECT(parse("SELECT table_name. FROM table_name;"sv).is_error());
EXPECT(parse("SELECT column_name AS FROM table_name;"sv).is_error());
EXPECT(parse("SELECT * FROM ("sv).is_error());
EXPECT(parse("SELECT * FROM ()"sv).is_error());
EXPECT(parse("SELECT * FROM ();"sv).is_error());
EXPECT(parse("SELECT * FROM (table_name1)"sv).is_error());
EXPECT(parse("SELECT * FROM (table_name1, )"sv).is_error());
EXPECT(parse("SELECT * FROM (table_name1, table_name2)"sv).is_error());
EXPECT(parse("SELECT * FROM table_name"sv).is_error());
EXPECT(parse("SELECT * FROM table_name AS;"sv).is_error());
EXPECT(parse("SELECT * FROM table_name WHERE;"sv).is_error());
EXPECT(parse("SELECT * FROM table_name WHERE 1 ==1"sv).is_error());
EXPECT(parse("SELECT * FROM table_name GROUP;"sv).is_error());
EXPECT(parse("SELECT * FROM table_name GROUP BY;"sv).is_error());
EXPECT(parse("SELECT * FROM table_name GROUP BY column_name"sv).is_error());
EXPECT(parse("SELECT * FROM table_name ORDER:"sv).is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name"sv).is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name COLLATE:"sv).is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name COLLATE collation"sv).is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name NULLS;"sv).is_error());
EXPECT(parse("SELECT * FROM table_name ORDER BY column_name NULLS SECOND;"sv).is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT;"sv).is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT 12"sv).is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT 12 OFFSET;"sv).is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT 12 OFFSET 15"sv).is_error());
EXPECT(parse("SELECT * FROM table_name LIMIT 15, 16;"sv).is_error());
struct Type {
SQL::AST::ResultType type;
@ -655,51 +655,51 @@ TEST_CASE(select)
};
Vector<Type> all { { SQL::AST::ResultType::All } };
Vector<From> from { { {}, "TABLE_NAME", {} } };
Vector<From> from { { {}, "TABLE_NAME"sv, {} } };
validate("SELECT * FROM table_name;", { { SQL::AST::ResultType::All } }, from, false, 0, false, {}, false, false);
validate("SELECT table_name.* FROM table_name;", { { SQL::AST::ResultType::Table, "TABLE_NAME" } }, from, false, 0, false, {}, false, false);
validate("SELECT column_name AS alias FROM table_name;", { { SQL::AST::ResultType::Expression, "ALIAS" } }, from, false, 0, false, {}, false, false);
validate("SELECT table_name.column_name AS alias FROM table_name;", { { SQL::AST::ResultType::Expression, "ALIAS" } }, from, false, 0, false, {}, false, false);
validate("SELECT schema_name.table_name.column_name AS alias FROM table_name;", { { SQL::AST::ResultType::Expression, "ALIAS" } }, from, false, 0, false, {}, false, false);
validate("SELECT column_name AS alias, *, table_name.* FROM table_name;", { { SQL::AST::ResultType::Expression, "ALIAS" }, { SQL::AST::ResultType::All }, { SQL::AST::ResultType::Table, "TABLE_NAME" } }, from, false, 0, false, {}, false, false);
validate("SELECT * FROM table_name;"sv, { { SQL::AST::ResultType::All } }, from, false, 0, false, {}, false, false);
validate("SELECT table_name.* FROM table_name;"sv, { { SQL::AST::ResultType::Table, "TABLE_NAME"sv } }, from, false, 0, false, {}, false, false);
validate("SELECT column_name AS alias FROM table_name;"sv, { { SQL::AST::ResultType::Expression, "ALIAS"sv } }, from, false, 0, false, {}, false, false);
validate("SELECT table_name.column_name AS alias FROM table_name;"sv, { { SQL::AST::ResultType::Expression, "ALIAS"sv } }, from, false, 0, false, {}, false, false);
validate("SELECT schema_name.table_name.column_name AS alias FROM table_name;"sv, { { SQL::AST::ResultType::Expression, "ALIAS"sv } }, from, false, 0, false, {}, false, false);
validate("SELECT column_name AS alias, *, table_name.* FROM table_name;"sv, { { SQL::AST::ResultType::Expression, "ALIAS"sv }, { SQL::AST::ResultType::All }, { SQL::AST::ResultType::Table, "TABLE_NAME"sv } }, from, false, 0, false, {}, false, false);
validate("SELECT * FROM table_name;", all, { { {}, "TABLE_NAME", {} } }, false, 0, false, {}, false, false);
validate("SELECT * FROM schema_name.table_name;", all, { { "SCHEMA_NAME", "TABLE_NAME", {} } }, false, 0, false, {}, false, false);
validate("SELECT * FROM schema_name.table_name AS alias;", all, { { "SCHEMA_NAME", "TABLE_NAME", "ALIAS" } }, false, 0, false, {}, false, false);
validate("SELECT * FROM schema_name.table_name AS alias, table_name2, table_name3 AS table_name4;", all, { { "SCHEMA_NAME", "TABLE_NAME", "ALIAS" }, { {}, "TABLE_NAME2", {} }, { {}, "TABLE_NAME3", "TABLE_NAME4" } }, false, 0, false, {}, false, false);
validate("SELECT * FROM table_name;"sv, all, { { {}, "TABLE_NAME"sv, {} } }, false, 0, false, {}, false, false);
validate("SELECT * FROM schema_name.table_name;"sv, all, { { "SCHEMA_NAME"sv, "TABLE_NAME"sv, {} } }, false, 0, false, {}, false, false);
validate("SELECT * FROM schema_name.table_name AS alias;"sv, all, { { "SCHEMA_NAME"sv, "TABLE_NAME"sv, "ALIAS"sv } }, false, 0, false, {}, false, false);
validate("SELECT * FROM schema_name.table_name AS alias, table_name2, table_name3 AS table_name4;"sv, all, { { "SCHEMA_NAME"sv, "TABLE_NAME"sv, "ALIAS"sv }, { {}, "TABLE_NAME2"sv, {} }, { {}, "TABLE_NAME3"sv, "TABLE_NAME4"sv } }, false, 0, false, {}, false, false);
validate("SELECT * FROM table_name WHERE column_name IS NOT NULL;", all, from, true, 0, false, {}, false, false);
validate("SELECT * FROM table_name WHERE column_name IS NOT NULL;"sv, all, from, true, 0, false, {}, false, false);
validate("SELECT * FROM table_name GROUP BY column_name;", all, from, false, 1, false, {}, false, false);
validate("SELECT * FROM table_name GROUP BY column1, column2, column3;", all, from, false, 3, false, {}, false, false);
validate("SELECT * FROM table_name GROUP BY column_name HAVING 'abc';", all, from, false, 1, true, {}, false, false);
validate("SELECT * FROM table_name GROUP BY column_name;"sv, all, from, false, 1, false, {}, false, false);
validate("SELECT * FROM table_name GROUP BY column1, column2, column3;"sv, all, from, false, 3, false, {}, false, false);
validate("SELECT * FROM table_name GROUP BY column_name HAVING 'abc';"sv, all, from, false, 1, true, {}, false, false);
validate("SELECT * FROM table_name ORDER BY column_name;", all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name COLLATE collation;", all, from, false, 0, false, { { "COLLATION", SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name ASC;", all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name DESC;", all, from, false, 0, false, { { {}, SQL::Order::Descending, SQL::Nulls::Last } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name ASC NULLS LAST;", all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::Last } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name DESC NULLS FIRST;", all, from, false, 0, false, { { {}, SQL::Order::Descending, SQL::Nulls::First } }, false, false);
validate("SELECT * FROM table_name ORDER BY column1, column2 DESC, column3 NULLS LAST;", all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First }, { {}, SQL::Order::Descending, SQL::Nulls::Last }, { {}, SQL::Order::Ascending, SQL::Nulls::Last } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name;"sv, all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name COLLATE collation;"sv, all, from, false, 0, false, { { "COLLATION"sv, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name ASC;"sv, all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name DESC;"sv, all, from, false, 0, false, { { {}, SQL::Order::Descending, SQL::Nulls::Last } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name ASC NULLS LAST;"sv, all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::Last } }, false, false);
validate("SELECT * FROM table_name ORDER BY column_name DESC NULLS FIRST;"sv, all, from, false, 0, false, { { {}, SQL::Order::Descending, SQL::Nulls::First } }, false, false);
validate("SELECT * FROM table_name ORDER BY column1, column2 DESC, column3 NULLS LAST;"sv, all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First }, { {}, SQL::Order::Descending, SQL::Nulls::Last }, { {}, SQL::Order::Ascending, SQL::Nulls::Last } }, false, false);
validate("SELECT * FROM table_name LIMIT 15;", all, from, false, 0, false, {}, true, false);
validate("SELECT * FROM table_name LIMIT 15 OFFSET 16;", all, from, false, 0, false, {}, true, true);
validate("SELECT * FROM table_name LIMIT 15;"sv, all, from, false, 0, false, {}, true, false);
validate("SELECT * FROM table_name LIMIT 15 OFFSET 16;"sv, all, from, false, 0, false, {}, true, true);
}
TEST_CASE(common_table_expression)
{
EXPECT(parse("WITH").is_error());
EXPECT(parse("WITH;").is_error());
EXPECT(parse("WITH DELETE FROM table_name;").is_error());
EXPECT(parse("WITH table_name DELETE FROM table_name;").is_error());
EXPECT(parse("WITH table_name AS DELETE FROM table_name;").is_error());
EXPECT(parse("WITH RECURSIVE table_name DELETE FROM table_name;").is_error());
EXPECT(parse("WITH RECURSIVE table_name AS DELETE FROM table_name;").is_error());
EXPECT(parse("WITH"sv).is_error());
EXPECT(parse("WITH;"sv).is_error());
EXPECT(parse("WITH DELETE FROM table_name;"sv).is_error());
EXPECT(parse("WITH table_name DELETE FROM table_name;"sv).is_error());
EXPECT(parse("WITH table_name AS DELETE FROM table_name;"sv).is_error());
EXPECT(parse("WITH RECURSIVE table_name DELETE FROM table_name;"sv).is_error());
EXPECT(parse("WITH RECURSIVE table_name AS DELETE FROM table_name;"sv).is_error());
// Below are otherwise valid common-table-expressions, but attached to statements which do not allow them.
EXPECT(parse("WITH table_name AS (SELECT * AS TABLE) CREATE TABLE test ( column1 );").is_error());
EXPECT(parse("WITH table_name AS (SELECT * FROM table_name) DROP TABLE test;").is_error());
EXPECT(parse("WITH table_name AS (SELECT * AS TABLE) CREATE TABLE test ( column1 );"sv).is_error());
EXPECT(parse("WITH table_name AS (SELECT * FROM table_name) DROP TABLE test;"sv).is_error());
struct SelectedTableList {
struct SelectedTable {
@ -739,25 +739,25 @@ TEST_CASE(common_table_expression)
}
};
validate("WITH table_name AS (SELECT * FROM table_name) DELETE FROM table_name;", { false, { { "TABLE_NAME" } } });
validate("WITH table_name (column_name) AS (SELECT * FROM table_name) DELETE FROM table_name;", { false, { { "TABLE_NAME", { "COLUMN_NAME" } } } });
validate("WITH table_name (column1, column2) AS (SELECT * FROM table_name) DELETE FROM table_name;", { false, { { "TABLE_NAME", { "COLUMN1", "COLUMN2" } } } });
validate("WITH RECURSIVE table_name AS (SELECT * FROM table_name) DELETE FROM table_name;", { true, { { "TABLE_NAME", {} } } });
validate("WITH table_name AS (SELECT * FROM table_name) DELETE FROM table_name;"sv, { false, { { "TABLE_NAME"sv } } });
validate("WITH table_name (column_name) AS (SELECT * FROM table_name) DELETE FROM table_name;"sv, { false, { { "TABLE_NAME"sv, { "COLUMN_NAME"sv } } } });
validate("WITH table_name (column1, column2) AS (SELECT * FROM table_name) DELETE FROM table_name;"sv, { false, { { "TABLE_NAME"sv, { "COLUMN1"sv, "COLUMN2"sv } } } });
validate("WITH RECURSIVE table_name AS (SELECT * FROM table_name) DELETE FROM table_name;"sv, { true, { { "TABLE_NAME"sv, {} } } });
}
TEST_CASE(nested_subquery_limit)
{
auto subquery = String::formatted("{:(^{}}table_name{:)^{}}", "", SQL::AST::Limits::maximum_subquery_depth - 1, "", SQL::AST::Limits::maximum_subquery_depth - 1);
EXPECT(!parse(String::formatted("SELECT * FROM {};", subquery)).is_error());
EXPECT(parse(String::formatted("SELECT * FROM ({});", subquery)).is_error());
EXPECT(!parse(String::formatted("SELECT * FROM {};"sv, subquery)).is_error());
EXPECT(parse(String::formatted("SELECT * FROM ({});"sv, subquery)).is_error());
}
TEST_CASE(describe_table)
{
EXPECT(parse("DESCRIBE").is_error());
EXPECT(parse("DESCRIBE;").is_error());
EXPECT(parse("DESCRIBE TABLE;").is_error());
EXPECT(parse("DESCRIBE table_name;").is_error());
EXPECT(parse("DESCRIBE"sv).is_error());
EXPECT(parse("DESCRIBE;"sv).is_error());
EXPECT(parse("DESCRIBE TABLE;"sv).is_error());
EXPECT(parse("DESCRIBE table_name;"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table) {
auto result = parse(sql);
@ -773,6 +773,6 @@ TEST_CASE(describe_table)
EXPECT_EQ(describe_table_statement.qualified_table_name()->table_name(), expected_table);
};
validate("DESCRIBE TABLE TableName;", {}, "TABLENAME");
validate("DESCRIBE TABLE SchemaName.TableName;", "SCHEMANAME", "TABLENAME");
validate("DESCRIBE TABLE TableName;"sv, {}, "TABLENAME"sv);
validate("DESCRIBE TABLE SchemaName.TableName;"sv, "SCHEMANAME"sv, "TABLENAME"sv);
}

6
Tests/LibTLS/TestTLSHandshake.cpp
View file

@ -15,7 +15,7 @@
static char const* ca_certs_file = "./ca_certs.ini";
static int port = 443;
constexpr char const* DEFAULT_SERVER { "www.google.com" };
constexpr auto DEFAULT_SERVER = "www.google.com"sv;
static ByteBuffer operator""_b(char const* string, size_t length)
{
@ -101,8 +101,8 @@ TEST_CASE(test_TLS_hello_handshake)
return;
}
auto* the_server = DEFAULT_SERVER;
if (!tls->write_or_error(StringView(the_server).bytes())) {
auto the_server = DEFAULT_SERVER;
if (!tls->write_or_error(the_server.bytes())) {
FAIL("write(1) failed");
return;
}

2
Tests/LibTextCodec/TestTextDecoders.cpp
View file

@ -12,7 +12,7 @@ TEST_CASE(test_utf8_decode)
{
auto decoder = TextCodec::UTF8Decoder();
// Bytes for U+1F600 GRINNING FACE
auto test_string = "\xf0\x9f\x98\x80";
auto test_string = "\xf0\x9f\x98\x80"sv;
Vector<u32> processed_code_points;
decoder.process(test_string, [&](u32 code_point) {

14
Tests/LibUnicode/TestUnicodeLocale.cpp
View file

@ -259,9 +259,9 @@ TEST_CASE(parse_unicode_locale_id_with_other_extension)
fail("en-z-aaa-a"sv);
fail("en-0-aaa-a"sv);
pass("en-z-aa", { 'z', "aa"sv });
pass("en-z-aa-bbb", { 'z', "aa-bbb"sv });
pass("en-z-aa-bbb-cccccccc", { 'z', "aa-bbb-cccccccc"sv });
pass("en-z-aa"sv, { 'z', "aa"sv });
pass("en-z-aa-bbb"sv, { 'z', "aa-bbb"sv });
pass("en-z-aa-bbb-cccccccc"sv, { 'z', "aa-bbb-cccccccc"sv });
}
TEST_CASE(parse_unicode_locale_id_with_private_use_extension)
@ -282,10 +282,10 @@ TEST_CASE(parse_unicode_locale_id_with_private_use_extension)
fail("en-x-aaa-"sv);
fail("en-x-aaa-aaaaaaaaa"sv);
pass("en-x-a", { "a"sv });
pass("en-x-aaaaaaaa", { "aaaaaaaa"sv });
pass("en-x-aaa-bbb", { "aaa"sv, "bbb"sv });
pass("en-x-aaa-x-bbb", { "aaa"sv, "x"sv, "bbb"sv });
pass("en-x-a"sv, { "a"sv });
pass("en-x-aaaaaaaa"sv, { "aaaaaaaa"sv });
pass("en-x-aaa-bbb"sv, { "aaa"sv, "bbb"sv });
pass("en-x-aaa-x-bbb"sv, { "aaa"sv, "x"sv, "bbb"sv });
}
TEST_CASE(canonicalize_unicode_locale_id)

28
Tests/LibWeb/TestHTMLTokenizer.cpp
View file

@ -42,9 +42,9 @@ using Token = Web::HTML::HTMLToken;
EXPECT_EQ(current_token->code_point(), (u32)(character)); \
NEXT_TOKEN();
#define EXPECT_CHARACTER_TOKENS(string) \
for (auto c : StringView(#string)) { \
EXPECT_CHARACTER_TOKEN(c); \
#define EXPECT_CHARACTER_TOKENS(string) \
for (auto c : #string##sv) { \
EXPECT_CHARACTER_TOKEN(c); \
}
#define EXPECT_COMMENT_TOKEN() \
@ -87,7 +87,7 @@ static u32 hash_tokens(Vector<Token> const& tokens)
TEST_CASE(empty)
{
auto tokens = run_tokenizer("");
auto tokens = run_tokenizer(""sv);
BEGIN_ENUMERATION(tokens);
EXPECT_END_OF_FILE_TOKEN();
END_ENUMERATION();
@ -95,7 +95,7 @@ TEST_CASE(empty)
TEST_CASE(basic)
{
auto tokens = run_tokenizer("<html><head></head><body></body></html>");
auto tokens = run_tokenizer("<html><head></head><body></body></html>"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_START_TAG_TOKEN(html);
EXPECT_START_TAG_TOKEN(head);
@ -109,7 +109,7 @@ TEST_CASE(basic)
TEST_CASE(basic_with_text)
{
auto tokens = run_tokenizer("<p>This is some text.</p>");
auto tokens = run_tokenizer("<p>This is some text.</p>"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_START_TAG_TOKEN(p);
EXPECT_CHARACTER_TOKENS(This is some text.);
@ -120,7 +120,7 @@ TEST_CASE(basic_with_text)
TEST_CASE(unquoted_attributes)
{
auto tokens = run_tokenizer("<p foo=bar>");
auto tokens = run_tokenizer("<p foo=bar>"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_START_TAG_TOKEN(p);
EXPECT_TAG_TOKEN_ATTRIBUTE_COUNT(1);
@ -131,7 +131,7 @@ TEST_CASE(unquoted_attributes)
TEST_CASE(single_quoted_attributes)
{
auto tokens = run_tokenizer("<p foo='bar'>");
auto tokens = run_tokenizer("<p foo='bar'>"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_START_TAG_TOKEN(p);
EXPECT_TAG_TOKEN_ATTRIBUTE_COUNT(1);
@ -142,7 +142,7 @@ TEST_CASE(single_quoted_attributes)
TEST_CASE(double_quoted_attributes)
{
auto tokens = run_tokenizer("<p foo=\"bar\">");
auto tokens = run_tokenizer("<p foo=\"bar\">"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_START_TAG_TOKEN(p);
EXPECT_TAG_TOKEN_ATTRIBUTE_COUNT(1);
@ -153,7 +153,7 @@ TEST_CASE(double_quoted_attributes)
TEST_CASE(multiple_attributes)
{
auto tokens = run_tokenizer("<p foo=\"bar\" baz=foobar foo2=\"bar2\">");
auto tokens = run_tokenizer("<p foo=\"bar\" baz=foobar foo2=\"bar2\">"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_START_TAG_TOKEN(p);
EXPECT_TAG_TOKEN_ATTRIBUTE_COUNT(3);
@ -166,7 +166,7 @@ TEST_CASE(multiple_attributes)
TEST_CASE(character_reference_in_attribute)
{
auto tokens = run_tokenizer("<p foo=a&amp;b bar='a&#38;b' baz=\"a&#x26;b\">");
auto tokens = run_tokenizer("<p foo=a&amp;b bar='a&#38;b' baz=\"a&#x26;b\">"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_START_TAG_TOKEN(p);
EXPECT_TAG_TOKEN_ATTRIBUTE_COUNT(3);
@ -179,7 +179,7 @@ TEST_CASE(character_reference_in_attribute)
TEST_CASE(comment)
{
auto tokens = run_tokenizer("<p><!-- This is a comment --></p>");
auto tokens = run_tokenizer("<p><!-- This is a comment --></p>"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_START_TAG_TOKEN(p);
EXPECT_COMMENT_TOKEN();
@ -190,7 +190,7 @@ TEST_CASE(comment)
TEST_CASE(doctype)
{
auto tokens = run_tokenizer("<!DOCTYPE html><html></html>");
auto tokens = run_tokenizer("<!DOCTYPE html><html></html>"sv);
BEGIN_ENUMERATION(tokens);
EXPECT_DOCTYPE_TOKEN();
EXPECT_START_TAG_TOKEN(html);
@ -201,7 +201,7 @@ TEST_CASE(doctype)
// If that changes, or something is added to the test HTML, the hash needs to be adjusted.
TEST_CASE(regression)
{
auto file = MUST(Core::Stream::File::open("/usr/Tests/LibWeb/tokenizer-test.html", Core::Stream::OpenMode::Read));
auto file = MUST(Core::Stream::File::open("/usr/Tests/LibWeb/tokenizer-test.html"sv, Core::Stream::OpenMode::Read));
auto file_size = MUST(file->size());
auto content = MUST(ByteBuffer::create_uninitialized(file_size));
MUST(file->read(content.bytes()));

4
Tests/LibXML/TestParser.cpp
View file

@ -15,7 +15,7 @@ TEST_CASE(char_data_ending)
// but it did _not_ consume it and would instead tell GenericLexer that it should stop consuming characters. Therefore, we only consumed 2 characters.
// Then, it would see that we are in the state where we've seen the full `]]>` and try to take off three characters from the end of the consumed
// input when we only have 2 characters, causing an assertion failure as we are asking to take off more characters than there really is.
XML::Parser parser("<C>]]>");
XML::Parser parser("<C>]]>"sv);
(void)parser.parse();
return Test::Crash::Failure::DidNotCrash;
});
@ -24,7 +24,7 @@ TEST_CASE(char_data_ending)
TEST_CASE(character_reference_integer_overflow)
{
EXPECT_NO_CRASH("parsing character references that do not fit in 32 bits should not crash", [] {
XML::Parser parser("<G>&#6666666666");
XML::Parser parser("<G>&#6666666666"sv);
(void)parser.parse();
return Test::Crash::Failure::DidNotCrash;
});

2
Tests/Spreadsheet/test-spreadsheet.cpp
View file

@ -38,7 +38,7 @@ TESTJS_RUN_FILE_FUNCTION(String const&, JS::Interpreter& interpreter, JS::Execut
run_file(LexicalPath::join(Test::JS::g_test_root, s_spreadsheet_runtime_path).string());
#endif
run_file("mock.test-common.js");
run_file("mock.test-common.js"sv);
return Test::JS::RunFileHookResult::RunAsNormal;
}