LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-09 18:16:09 +03:00
Code Issues Packages Projects Releases Wiki Activity
5e1499d104
ladybird/Tests/AK/TestStringUtils.cpp

439 lines
18 KiB
C++
Raw Normal View History

AK: Add missing copyright header to TestStringUtils.cpp
2020-05-09 15:06:31 +03:00
/*
* Copyright (c) 2020, Fei Wu <f.eiwu@yahoo.com>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 11:24:48 +03:00
* SPDX-License-Identifier: BSD-2-Clause
AK: Add missing copyright header to TestStringUtils.cpp
2020-05-09 15:06:31 +03:00
*/
AK+Userland: Move AK/TestSuite.h into LibTest and rework Tests' CMake As many macros as possible are moved to Macros.h, while the macros to create a test case are moved to TestCase.h. TestCase is now the only user-facing header for creating a test case. TestSuite and its helpers have moved into a .cpp file. Instead of requiring a TEST_MAIN macro to be instantiated into the test file, a TestMain.cpp file is provided instead that will be linked against each test. This has the side effect that, if we wanted to have test cases split across multiple files, it's as simple as adding them all to the same executable. The test main should be portable to kernel mode as well, so if there's a set of tests that should be run in self-test mode in kernel space, we can accomodate that. A new serenity_test CMake function streamlines adding a new test with arguments for the test source file, subdirectory under /usr/Tests to install the test application and an optional list of libraries to link against the test application. To accomodate future test where the provided TestMain.cpp is not suitable (e.g. test-js), a CUSTOM_MAIN parameter can be passed to the function to not link against the boilerplate main function.
2021-04-25 08:53:23 +03:00
#include <LibTest/TestCase.h>
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
AK: Ensure string types are actually considered hash-compatible The AnyString concept is currently broken because it checks whether a StringView is constructible from a type T. The StringView constructors, however, only accept constant rvalue references - i.e. `T const&`. This also adds a test to ensure this continues to work.
2023-02-02 18:48:11 +03:00
#include <AK/ByteBuffer.h>
#include <AK/Concepts.h>
#include <AK/FlyString.h>
#include <AK/String.h>
AK: Untangle TestSuite assertions a bit
2021-02-23 10:33:03 +03:00
#include <AK/StringUtils.h>
AK+Everywhere: Stop including Vector.h from StringView.h Preparation for using Error.h from Vector.h. This required moving some things out of line.
2021-11-10 13:05:21 +03:00
#include <AK/Vector.h>
AK: Untangle TestSuite assertions a bit
2021-02-23 10:33:03 +03:00
AK: Ensure string types are actually considered hash-compatible The AnyString concept is currently broken because it checks whether a StringView is constructible from a type T. The StringView constructors, however, only accept constant rvalue references - i.e. `T const&`. This also adds a test to ensure this continues to work.
2023-02-02 18:48:11 +03:00
TEST_CASE(hash_compatible)
{
static_assert(AK::Concepts::HashCompatible<String, StringView>);
static_assert(AK::Concepts::HashCompatible<String, FlyString>);
static_assert(AK::Concepts::HashCompatible<StringView, String>);
static_assert(AK::Concepts::HashCompatible<StringView, FlyString>);
static_assert(AK::Concepts::HashCompatible<FlyString, String>);
static_assert(AK::Concepts::HashCompatible<FlyString, StringView>);
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:19:34 +03:00
static_assert(AK::Concepts::HashCompatible<ByteString, StringView>);
static_assert(AK::Concepts::HashCompatible<ByteString, DeprecatedFlyString>);
static_assert(AK::Concepts::HashCompatible<StringView, ByteString>);
AK: Ensure string types are actually considered hash-compatible The AnyString concept is currently broken because it checks whether a StringView is constructible from a type T. The StringView constructors, however, only accept constant rvalue references - i.e. `T const&`. This also adds a test to ensure this continues to work.
2023-02-02 18:48:11 +03:00
static_assert(AK::Concepts::HashCompatible<StringView, DeprecatedFlyString>);
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:19:34 +03:00
static_assert(AK::Concepts::HashCompatible<DeprecatedFlyString, ByteString>);
AK: Ensure string types are actually considered hash-compatible The AnyString concept is currently broken because it checks whether a StringView is constructible from a type T. The StringView constructors, however, only accept constant rvalue references - i.e. `T const&`. This also adds a test to ensure this continues to work.
2023-02-02 18:48:11 +03:00
static_assert(AK::Concepts::HashCompatible<DeprecatedFlyString, StringView>);
static_assert(AK::Concepts::HashCompatible<StringView, ByteBuffer>);
static_assert(AK::Concepts::HashCompatible<ByteBuffer, StringView>);
}
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
TEST_CASE(matches_null)
{
EXPECT(AK::StringUtils::matches(StringView(), StringView()));
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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));
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(!AK::StringUtils::matches(""sv, StringView()));
EXPECT(!AK::StringUtils::matches("a"sv, StringView()));
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
}
TEST_CASE(matches_empty)
{
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(AK::StringUtils::matches(""sv, ""sv));
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(AK::StringUtils::matches(""sv, "*"sv));
EXPECT(!AK::StringUtils::matches(""sv, "?"sv));
EXPECT(!AK::StringUtils::matches(""sv, "a"sv));
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(!AK::StringUtils::matches("a"sv, ""sv));
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
}
TEST_CASE(matches_case_sensitive)
{
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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));
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
}
TEST_CASE(matches_case_insensitive)
{
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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));
AK: Move the wildcard-matching implementation to StringUtils Provide wrappers in the String and StringView classes, and add some tests.
2020-02-26 10:25:24 +03:00
}
AK: Make String::matches() capable of reporting match positions too Also, rewrite StringUtils::match(), because the old implementation was fairly broken, e.g. "acdcxb" would *not* match "a*?b".
2020-10-25 08:34:39 +03:00
TEST_CASE(matches_with_positions)
{
Vector<AK::MaskSpan> spans;
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(AK::StringUtils::matches("abbb"sv, "a*"sv, CaseSensitivity::CaseSensitive, &spans));
AK: Make String::matches() capable of reporting match positions too Also, rewrite StringUtils::match(), because the old implementation was fairly broken, e.g. "acdcxb" would *not* match "a*?b".
2020-10-25 08:34:39 +03:00
EXPECT(spans == Vector<AK::MaskSpan>({ { 1, 3 } }));
spans.clear();
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(AK::StringUtils::matches("abbb"sv, "?*"sv, CaseSensitivity::CaseSensitive, &spans));
AK: Make String::matches() capable of reporting match positions too Also, rewrite StringUtils::match(), because the old implementation was fairly broken, e.g. "acdcxb" would *not* match "a*?b".
2020-10-25 08:34:39 +03:00
EXPECT_EQ(spans, Vector<AK::MaskSpan>({ { 0, 1 }, { 1, 3 } }));
spans.clear();
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(AK::StringUtils::matches("acdcxb"sv, "a*c?b"sv, CaseSensitivity::CaseSensitive, &spans));
AK: Make String::matches() capable of reporting match positions too Also, rewrite StringUtils::match(), because the old implementation was fairly broken, e.g. "acdcxb" would *not* match "a*?b".
2020-10-25 08:34:39 +03:00
EXPECT_EQ(spans, Vector<AK::MaskSpan>({ { 1, 2 }, { 4, 1 } }));
spans.clear();
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(AK::StringUtils::matches("aaaa"sv, "A*"sv, CaseSensitivity::CaseInsensitive, &spans));
AK: Make String::matches() capable of reporting match positions too Also, rewrite StringUtils::match(), because the old implementation was fairly broken, e.g. "acdcxb" would *not* match "a*?b".
2020-10-25 08:34:39 +03:00
EXPECT_EQ(spans, Vector<AK::MaskSpan>({ { 1, 3 } }));
}
AK: Allow trailing '*'s in a glob pattern to match nothing Fixes part of #4607.
2020-12-28 23:34:12 +03:00
// #4607
TEST_CASE(matches_trailing)
{
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
EXPECT(AK::StringUtils::matches("ab"sv, "ab*"sv));
EXPECT(AK::StringUtils::matches("ab"sv, "ab****"sv));
EXPECT(AK::StringUtils::matches("ab"sv, "*ab****"sv));
AK: Allow trailing '*'s in a glob pattern to match nothing Fixes part of #4607.
2020-12-28 23:34:12 +03:00
}
AK: Make StringUtils::matches() handle escaping correctly Previously any backslash and the character following it were ignored. This commit adds a fall through to match the character following the backslash without checking whether it is "special".
2022-12-16 21:20:53 +03:00
TEST_CASE(match_backslash_escape)
{
EXPECT(AK::StringUtils::matches("ab*"sv, "ab\\*"sv));
EXPECT(!AK::StringUtils::matches("abc"sv, "ab\\*"sv));
EXPECT(!AK::StringUtils::matches("abcd"sv, "ab\\*"sv));
EXPECT(AK::StringUtils::matches("ab?"sv, "ab\\?"sv));
EXPECT(!AK::StringUtils::matches("abc"sv, "ab\\?"sv));
}
TEST_CASE(match_trailing_backslash)
{
EXPECT(AK::StringUtils::matches("x\\"sv, "x\\"sv));
EXPECT(AK::StringUtils::matches("x\\"sv, "x\\\\"sv));
}
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
TEST_CASE(convert_to_int)
{
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
auto value = AK::StringUtils::convert_to_int(StringView());
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_int(""sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_int("a"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_int("+"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_int("-"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual = AK::StringUtils::convert_to_int("0"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 0);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_int("1"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 1);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_int("+1"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 1);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_int("-1"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), -1);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_int("01"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 1);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_int("12345"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 12345);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_int("-12345"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), -12345);
AK: Trim whitespace in StringUtils::convert_to_{int,uint,uint_from_hex}() Personally I found this unintuitive at first, but it is in line with strtol(), Python's int() or JavaScript's parseInt(), so I guess it makes sense. Fixes #4097.
2020-11-16 21:30:22 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_int(" \t-12345 \n\n"sv);
AK: Trim whitespace in StringUtils::convert_to_{int,uint,uint_from_hex}() Personally I found this unintuitive at first, but it is in line with strtol(), Python's int() or JavaScript's parseInt(), so I guess it makes sense. Fixes #4097.
2020-11-16 21:30:22 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), -12345);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual_i8 = AK::StringUtils::convert_to_int<i8>("-1"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(actual_i8.has_value());
EXPECT_EQ(actual_i8.value(), -1);
EXPECT_EQ(sizeof(actual_i8.value()), (size_t)1);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual_i8 = AK::StringUtils::convert_to_int<i8>("128"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(!actual_i8.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual_i16 = AK::StringUtils::convert_to_int<i16>("-1"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(actual_i16.has_value());
EXPECT_EQ(actual_i16.value(), -1);
EXPECT_EQ(sizeof(actual_i16.value()), (size_t)2);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual_i16 = AK::StringUtils::convert_to_int<i16>("32768"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(!actual_i16.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual_i32 = AK::StringUtils::convert_to_int<i32>("-1"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(actual_i32.has_value());
EXPECT_EQ(actual_i32.value(), -1);
EXPECT_EQ(sizeof(actual_i32.value()), (size_t)4);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual_i32 = AK::StringUtils::convert_to_int<i32>("2147483648"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(!actual_i32.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual_i64 = AK::StringUtils::convert_to_int<i64>("-1"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(actual_i64.has_value());
EXPECT_EQ(actual_i64.value(), -1);
EXPECT_EQ(sizeof(actual_i64.value()), (size_t)8);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual_i64 = AK::StringUtils::convert_to_int<i64>("9223372036854775808"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(!actual_i64.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
}
TEST_CASE(convert_to_uint)
{
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
auto value = AK::StringUtils::convert_to_uint(StringView());
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint(""sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint("a"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint("+"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint("-"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint("+1"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint("-1"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT(!value.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual = AK::StringUtils::convert_to_uint("0"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 0u);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint("1"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 1u);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint("01"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 1u);
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint("12345"sv);
AK: Make string-to-number conversion helpers return Optional Get rid of the weird old signature: - int StringType::to_int(bool& ok) const And replace it with sensible new signature: - Optional<int> StringType::to_int() const
2020-06-12 22:07:52 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 12345u);
AK: Trim whitespace in StringUtils::convert_to_{int,uint,uint_from_hex}() Personally I found this unintuitive at first, but it is in line with strtol(), Python's int() or JavaScript's parseInt(), so I guess it makes sense. Fixes #4097.
2020-11-16 21:30:22 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint(" \t12345 \n\n"sv);
AK: Trim whitespace in StringUtils::convert_to_{int,uint,uint_from_hex}() Personally I found this unintuitive at first, but it is in line with strtol(), Python's int() or JavaScript's parseInt(), so I guess it makes sense. Fixes #4097.
2020-11-16 21:30:22 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 12345u);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual_u8 = AK::StringUtils::convert_to_uint<u8>("255"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(actual_u8.has_value());
EXPECT_EQ(actual_u8.value(), 255u);
EXPECT_EQ(sizeof(actual_u8.value()), (size_t)1);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual_u8 = AK::StringUtils::convert_to_uint<u8>("256"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(!actual_u8.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual_u16 = AK::StringUtils::convert_to_uint<u16>("65535"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(actual_u16.has_value());
EXPECT_EQ(actual_u16.value(), 65535u);
EXPECT_EQ(sizeof(actual_u16.value()), (size_t)2);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual_u16 = AK::StringUtils::convert_to_uint<u16>("65536"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(!actual_u16.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual_u32 = AK::StringUtils::convert_to_uint<u32>("4294967295"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(actual_u32.has_value());
EXPECT_EQ(actual_u32.value(), 4294967295ul);
EXPECT_EQ(sizeof(actual_u32.value()), (size_t)4);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual_u32 = AK::StringUtils::convert_to_uint<u32>("4294967296"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(!actual_u32.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual_u64 = AK::StringUtils::convert_to_uint<u64>("18446744073709551615"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(actual_u64.has_value());
EXPECT_EQ(actual_u64.value(), 18446744073709551615ull);
EXPECT_EQ(sizeof(actual_u64.value()), (size_t)8);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual_u64 = AK::StringUtils::convert_to_uint<u64>("18446744073709551616"sv);
AK: Test StringUtils::convert_to_int for different types
2020-12-20 08:30:22 +03:00
EXPECT(!actual_u64.has_value());
AK: Move to_int(), to_uint() implementations to StringUtils (#1338) Provide wrappers in String and StringView. Add some tests for the implementations.
2020-03-02 16:19:33 +03:00
}
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
TEST_CASE(convert_to_uint_from_octal)
{
auto value = AK::StringUtils::convert_to_uint_from_octal<u16>(StringView());
EXPECT(!value.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint_from_octal<u16>(""sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT(!value.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint_from_octal<u16>("a"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT(!value.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint_from_octal<u16>("+"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT(!value.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint_from_octal<u16>("-"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT(!value.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint_from_octal<u16>("+1"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT(!value.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint_from_octal<u16>("-1"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT(!value.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
value = AK::StringUtils::convert_to_uint_from_octal<u16>("8"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT(!value.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
auto actual = AK::StringUtils::convert_to_uint_from_octal<u16>("77777777"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT(!actual.has_value());
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("0"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 0u);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("1"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 1u);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("0755"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 0755u);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("755"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 0755u);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint_from_octal<u16>(" \t644 \n\n"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 0644u);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
actual = AK::StringUtils::convert_to_uint_from_octal<u16>("177777"sv);
AK: Add convert_to_uint_from_octal
2021-12-20 23:06:54 +03:00
EXPECT_EQ(actual.has_value(), true);
EXPECT_EQ(actual.value(), 0177777u);
}
AK: Pass correct length to `StringUtils::convert_to_floating_point()` Fixed the issue in StringUtils::convert_to_floating_point() where the end pointer of the trimmed string was not being passed, causing the function to consistently return 'None' when given strings with trailing whitespaces.
2023-10-14 11:42:59 +03:00
TEST_CASE(convert_to_floating_point)
{
auto number_string = " 123.45 "sv;
auto maybe_number = AK::StringUtils::convert_to_floating_point<float>(number_string, TrimWhitespace::Yes);
EXPECT_APPROXIMATE(maybe_number.value(), 123.45f);
}
AK: Expand string tests to include ends_with case insensitivity
2020-05-26 13:31:56 +03:00
TEST_CASE(ends_with)
{
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:19:34 +03:00
ByteString test_string = "ABCDEF";
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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));
AK: Expand string tests to include ends_with case insensitivity
2020-05-26 13:31:56 +03:00
}
AK: Add case insensitive version of starts_with
2020-07-18 19:59:38 +03:00
TEST_CASE(starts_with)
{
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:19:34 +03:00
ByteString test_string = "ABCDEF";
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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));
AK: Add case insensitive version of starts_with
2020-07-18 19:59:38 +03:00
}
AK: Enhance String::contains to allow case-insensitive searches
2020-10-21 00:07:03 +03:00
TEST_CASE(contains)
{
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:19:34 +03:00
ByteString test_string = "ABCDEFABCXYZ";
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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));
AK+Tests: Fix StringUtils::contains() being confused by repeating text Previously, case-insensitively searching the haystack "Go Go Back" for the needle "Go Back" would return false: 1. Match the first three characters. "Go ". 2. Notice that 'G' and 'B' don't match. 3. Skip ahead 3 characters, plus 1 for the outer for-loop. 4. Now, the haystack is effectively "o Back", so the match fails. Reducing the skip by 1 fixes this issue. I'm not 100% convinced this fixes all cases, but I haven't been able to find any cases where it doesn't work now. :^)
2022-03-18 21:02:07 +03:00
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:19:34 +03:00
ByteString command_palette_bug_string = "Go Go Back";
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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));
AK: Enhance String::contains to allow case-insensitive searches
2020-10-21 00:07:03 +03:00
}
AK: Add String{,View}::is_whitespace() +Tests!
2021-01-03 02:26:02 +03:00
TEST_CASE(is_whitespace)
{
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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));
AK: Add String{,View}::is_whitespace() +Tests!
2021-01-03 02:26:02 +03:00
}
AK+Tests: Correct off-by-one error when right-trimming text If the entire string you want to right-trim consists of characters you want to remove, we previously would incorrectly leave the first character there. For example: `trim("aaaaa", "a")` would return "a" instead of "". We can't use `i >= 0` in the loop since that would fail to detect underflow, so instead we keep `i` in the range `size .. 1` and then subtract 1 from it when reading the character. Added some trim() tests while I was at it. (And to confirm that this was the issue.)
2022-10-11 16:38:09 +03:00
TEST_CASE(trim)
{
EXPECT_EQ(AK::StringUtils::trim("aaa.a."sv, "."sv, TrimMode::Right), "aaa.a"sv);
EXPECT_EQ(AK::StringUtils::trim("...aaa"sv, "."sv, TrimMode::Left), "aaa"sv);
EXPECT_EQ(AK::StringUtils::trim("...aaa.a..."sv, "."sv, TrimMode::Both), "aaa.a"sv);
EXPECT_EQ(AK::StringUtils::trim("."sv, "."sv, TrimMode::Right), ""sv);
EXPECT_EQ(AK::StringUtils::trim("."sv, "."sv, TrimMode::Left), ""sv);
EXPECT_EQ(AK::StringUtils::trim("."sv, "."sv, TrimMode::Both), ""sv);
EXPECT_EQ(AK::StringUtils::trim("..."sv, "."sv, TrimMode::Both), ""sv);
}
AK: Add String{View,}::find(StringView) I personally mistook `find_first_of(StringView)` to be analogous to this so let's add a `find()` method that actually searches the string.
2021-01-12 22:58:45 +03:00
TEST_CASE(find)
{
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:19:34 +03:00
ByteString test_string = "1234567";
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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);
AK: Add String{View,}::find(StringView) I personally mistook `find_first_of(StringView)` to be analogous to this so let's add a `find()` method that actually searches the string.
2021-01-12 22:58:45 +03:00
}
AK: Add String{,Utils}::to_snakecase() This is an improved version of WrapperGenerator's snake_name(), which seems like the kind of thing that could be useful elsewhere but would end up getting duplicated - so let's add this to AK::String instead, like to_{lowercase,uppercase}().
2021-02-21 00:39:22 +03:00
TEST_CASE(to_snakecase)
{
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 20:32:29 +03:00
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");
AK: Add String{,Utils}::to_snakecase() This is an improved version of WrapperGenerator's snake_name(), which seems like the kind of thing that could be useful elsewhere but would end up getting duplicated - so let's add this to AK::String instead, like to_{lowercase,uppercase}().
2021-02-21 00:39:22 +03:00
}
AK: Implement method to convert a String/StringView to title case This implementation preserves consecutive spaces in the orginal string.
2021-08-26 20:55:41 +03:00
TEST_CASE(to_titlecase)
{
EXPECT_EQ(AK::StringUtils::to_titlecase(""sv), ""sv);
EXPECT_EQ(AK::StringUtils::to_titlecase("f"sv), "F"sv);
EXPECT_EQ(AK::StringUtils::to_titlecase("foobar"sv), "Foobar"sv);
EXPECT_EQ(AK::StringUtils::to_titlecase("Foobar"sv), "Foobar"sv);
EXPECT_EQ(AK::StringUtils::to_titlecase("FOOBAR"sv), "Foobar"sv);
EXPECT_EQ(AK::StringUtils::to_titlecase("foo bar"sv), "Foo Bar"sv);
EXPECT_EQ(AK::StringUtils::to_titlecase("foo bAR"sv), "Foo Bar"sv);
EXPECT_EQ(AK::StringUtils::to_titlecase("foo bar"sv), "Foo Bar"sv);
EXPECT_EQ(AK::StringUtils::to_titlecase("foo bar"sv), "Foo Bar"sv);
EXPECT_EQ(AK::StringUtils::to_titlecase(" foo bar "sv), " Foo Bar "sv);
AK: Do not append string bytes as code points when title-casing a string By appending individual bytes as code points, we were "breaking apart" multi-byte UTF-8 code points. This now behaves the same way as the invert_case() helper in StringUtils.
2022-10-20 15:44:18 +03:00
EXPECT_EQ(AK::StringUtils::to_titlecase("\xc3\xa7"sv), "\xc3\xa7"sv); // U+00E7 LATIN SMALL LETTER C WITH CEDILLA
EXPECT_EQ(AK::StringUtils::to_titlecase("\xe1\x80\x80"sv), "\xe1\x80\x80"sv); // U+1000 MYANMAR LETTER KA
AK: Implement method to convert a String/StringView to title case This implementation preserves consecutive spaces in the orginal string.
2021-08-26 20:55:41 +03:00
}
Reference in New Issue Copy Permalink