diff options
Diffstat (limited to 'test/test_utf8.cpp')
| -rw-r--r-- | test/test_utf8.cpp | 1125 |
1 files changed, 302 insertions, 823 deletions
diff --git a/test/test_utf8.cpp b/test/test_utf8.cpp index 8f1d655..d1737f7 100644 --- a/test/test_utf8.cpp +++ b/test/test_utf8.cpp @@ -38,10 +38,21 @@ constexpr char printableCharOffset = 0x20; constexpr auto invalidAscii = FudUtf8::invalidAsciiCode.character(); -auto generateInvalidAsciiChars() +auto invalidAsciiGenerator() { - Iota<utf8> iota{}; - return generate([]() { return Array<utf8, invalidAsciiSize>{}; }, [&]() { return iota().value(); }); + return Iota<uint16_t>{validAsciiSize, 1, invalidAsciiSize}; +} + +template <typename T> +auto toUtf8(T letter) +{ + return FudUtf8::make(static_cast<utf8>(letter)); +} + +template <typename T> +auto toLetter(T letter) +{ + return static_cast<char>(letter); } TEST(Utf8Test, Utf8Creation) @@ -187,123 +198,80 @@ TEST(Utf8Test, Utf8IsAscii) Iota<int16_t> charIota{0, 1, validAsciiSize}; - ASSERT_TRUE(allOf( - [&]() -> std::optional<char> { - auto value = charIota(); - return value ? std::optional<char>(static_cast<char>(*value)) : std::nullopt; - }, - charIsAscii)); + ASSERT_TRUE(allOf([&]() -> Option<char> { return charIota().map(toLetter<int16_t>); }, charIsAscii)); Iota<int16_t> invalidCharIota{validAsciiSize, 1, invalidAsciiSize}; - ASSERT_FALSE(anyOf( - [&]() -> std::optional<char> { - auto value = invalidCharIota(); - return value ? std::optional<char>(static_cast<char>(*value)) : std::nullopt; - }, - charIsAscii)); + ASSERT_FALSE(anyOf([&]() -> Option<char> { return invalidCharIota().map(toLetter<int16_t>); }, charIsAscii)); FudUtf8 unicode{FudUtf8::invalidAscii()}; ASSERT_FALSE(utf8IsAscii(unicode)); charIota.set(0); - ASSERT_TRUE(allOf( - [&]() -> std::optional<FudUtf8> { - auto value = charIota(); - return value ? std::optional<FudUtf8>(FudUtf8::make(static_cast<utf8>(*value))) : std::nullopt; - }, - utf8IsAscii)); + ASSERT_TRUE(allOf([&]() -> Option<FudUtf8> { return charIota().map(toUtf8<int16_t>); }, utf8IsAscii)); invalidCharIota.set(invalidAsciiSize); - ASSERT_FALSE(anyOf( - [&]() -> std::optional<FudUtf8> { - auto value = invalidCharIota(); - return value ? std::optional<FudUtf8>(FudUtf8::make(static_cast<utf8>(*value))) : std::nullopt; - }, - utf8IsAscii)); + ASSERT_FALSE(anyOf([&]() -> Option<FudUtf8> { return invalidCharIota().map(toUtf8<int16_t>); }, utf8IsAscii)); } -TEST(Utf8Test, Utf8IsAlphaNumeric) +template <typename T, size_t Size = SIZE_MAX> +struct SpanGenerator { + Span<T, Size> span; + size_t index{0}; + + void reset() + { + index = 0; + } + + Option<T> operator()() + { + if (index < span.size()) { + index++; + return span[index - 1]; + } + return NullOpt; + } +}; + +TEST(Utf8Test, Utf8IsAlphanumeric) { - constexpr size_t numAlphaNumericChars = 26 * 2 + 10; - Array<char, numAlphaNumericChars + 1> alphaNumericCharLiteral{ALPHA_NUMERIC_CHARS}; - Array<char, numAlphaNumericChars> alphaNumericChars{}; - copyMem<numAlphaNumericChars>(alphaNumericChars, alphaNumericCharLiteral); -#if 0 - ASSERT_TRUE(allOf(alphaNumericChars, charIsAlphanumeric)); - - auto alphaNumericSetResult{StaticSet<char, numAlphaNumericChars>::makeFromArray(alphaNumericChars)}; - ASSERT_TRUE(alphaNumericSetResult.isOkay()); - auto alphaNumericSet{std::move(alphaNumericSetResult.getOkay())}; - - constexpr size_t numNonAlphaNumericChars = validAsciiSize - numAlphaNumericChars; - FixedVector<char, numNonAlphaNumericChars> nonAlphaNumericChars{}; + constexpr size_t numAlphanumericChars = 26 * 2 + 10; + Array<char, numAlphanumericChars + 1> alphanumericCharLiteral{ALPHA_NUMERIC_CHARS}; + Array<char, numAlphanumericChars> alphanumericChars{}; + copyMem<numAlphanumericChars>(alphanumericChars, alphanumericCharLiteral); + + ASSERT_TRUE(allOf(alphanumericChars.span(), charIsAlphanumeric)); + + constexpr size_t numNonAlphanumericChars = validAsciiSize - numAlphanumericChars; + Vector<char> nonAlphanumericChars{}; for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!alphaNumericSet.isKey(idx)) { - ASSERT_TRUE(nonAlphaNumericChars.pushBack(idx)); + if (!charIsAlphanumeric(idx)) { + ASSERT_EQ(nonAlphanumericChars.pushBack(idx), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonAlphaNumericChars, charIsAlphanumeric)); + auto nonAlphanumericSpan{nonAlphanumericChars.span().takeOkay()}; + ASSERT_FALSE(anyOf(nonAlphanumericSpan, charIsAlphanumeric)); - auto invalidAsciiChars = generateInvalidAsciiChars(); + auto invalidAsciiChars = invalidAsciiGenerator(); ASSERT_FALSE(anyOf(invalidAsciiChars, charIsAlphanumeric)); - ASSERT_TRUE(allOf( - map(alphaNumericChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alphanumeric)); - ASSERT_FALSE(anyOf( - map(nonAlphaNumericChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alphanumeric)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alphanumeric)); - - ASSERT_TRUE(allOf( - map(alphaNumericChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alphanumeric)); - ASSERT_FALSE(anyOf( - map(nonAlphaNumericChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alphanumeric)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alphanumeric)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_alphanumeric(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_alphanumeric(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_alphanumeric(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_alphanumeric(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(alphaNumericChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_alphanumeric(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonAlphaNumericChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_alphanumeric(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonAlphaNumericChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_alphanumeric(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); -#endif + ASSERT_FALSE(utf8IsAlphanumeric(FudUtf8{Ascii{invalidAscii}})); + + auto iotaGenerator = invalidAsciiGenerator(); + auto generator = generate( + []() { return Array<utf8, invalidAsciiSize>{}; }, + [&]() { return iotaGenerator().map([](auto val) { return static_cast<utf8>(val); }); }); + + SpanGenerator<char, alphanumericChars.size()> alphanumericGenerator{alphanumericChars.span()}; + auto utf8AlphanumericGenerator = [&]() { return alphanumericGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8AlphanumericGenerator, utf8IsAlphanumeric)); + + SpanGenerator<char> nonAlphanumericGenerator{nonAlphanumericChars.span().takeOkay()}; + auto utf8NonAlphanumericGenerator = [&]() { return nonAlphanumericGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonAlphanumericGenerator, utf8IsAlphanumeric)); } -#if 0 TEST(Utf8Test, Utf8IsAlpha) { constexpr size_t numAlphaChars = sizeof(ALPHA_CHARS) - 1; @@ -311,75 +279,29 @@ TEST(Utf8Test, Utf8IsAlpha) Array<char, numAlphaChars> alphaChars{}; copyMem<numAlphaChars>(alphaChars, alphaCharLiteral); - ASSERT_TRUE(allOf(alphaChars, ext_lib_char_is_alpha)); - - auto alphaSetResult{StaticSet<char, numAlphaChars>::makeFromArray(alphaChars)}; - ASSERT_TRUE(alphaSetResult.isOkay()); - auto alphaSet{std::move(alphaSetResult.getOkay())}; + ASSERT_TRUE(allOf(alphaChars.span(), charIsAlpha)); - constexpr size_t numNonAlphaChars = validAsciiSize - numAlphaChars; - FixedVector<char, numNonAlphaChars> nonAlphaChars{}; + constexpr size_t numNonAlphanumericChars = validAsciiSize - numAlphaChars; + Vector<char> nonAlphaChars{}; for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!alphaSet.isKey(idx)) { - ASSERT_TRUE(nonAlphaChars.pushBack(idx)); + if (!charIsAlphanumeric(idx)) { + ASSERT_EQ(nonAlphaChars.pushBack(idx), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonAlphaChars, ext_lib_char_is_alpha)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_alpha)); - - ASSERT_TRUE(allOf( - map(alphaChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alpha)); - ASSERT_FALSE(anyOf( - map(nonAlphaChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alpha)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alpha)); - - ASSERT_TRUE(allOf( - map(alphaChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alpha)); - ASSERT_FALSE(anyOf( - map(nonAlphaChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alpha)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_alpha)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_alpha(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_alpha(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_alpha(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_alpha(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(alphaChars, [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_alpha(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonAlphaChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_alpha(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonAlphaChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_alpha(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonAlphaChars.span().takeOkay(), charIsAlpha)); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsAlpha)); + + ASSERT_FALSE(utf8IsAlpha(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, alphaChars.size()> alphaGenerator{alphaChars.span()}; + auto utf8AlphaGenerator = [&]() { return alphaGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8AlphaGenerator, utf8IsAlpha)); + + SpanGenerator<char> nonAlphaGenerator{nonAlphaChars.span().takeOkay()}; + auto utf8NonAlphaGenerator = [&]() { return nonAlphaGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonAlphaGenerator, utf8IsAlpha)); } TEST(Utf8Test, Utf8IsLower) @@ -389,75 +311,29 @@ TEST(Utf8Test, Utf8IsLower) Array<char, numLowerChars> lowerChars{}; copyMem<numLowerChars>(lowerChars, lowerCharLiteral); - ASSERT_TRUE(allOf(lowerChars, ext_lib_char_is_lowercase)); - - auto lowerSetResult{StaticSet<char, numLowerChars>::makeFromArray(lowerChars)}; - ASSERT_TRUE(lowerSetResult.isOkay()); - auto lowerSet{std::move(lowerSetResult.getOkay())}; + ASSERT_TRUE(allOf(lowerChars.span(), charIsLowercase)); constexpr size_t numNonLowerChars = validAsciiSize - numLowerChars; - FixedVector<char, numNonLowerChars> nonLowerChars{}; + Vector<char> nonLowerChars{}; for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!lowerSet.isKey(idx)) { - ASSERT_TRUE(nonLowerChars.pushBack(idx)); + if (!charIsLowercase(idx)) { + ASSERT_EQ(nonLowerChars.pushBack(idx), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonLowerChars, ext_lib_char_is_lowercase)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_lowercase)); - - ASSERT_TRUE(allOf( - map(lowerChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_lowercase)); - ASSERT_FALSE(anyOf( - map(nonLowerChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_lowercase)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_lowercase)); - - ASSERT_TRUE(allOf( - map(lowerChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_lowercase)); - ASSERT_FALSE(anyOf( - map(nonLowerChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_lowercase)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_lowercase)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_lowercase(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_lowercase(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_lowercase(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_lowercase(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(lowerChars, [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_lowercase(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonLowerChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_lowercase(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonLowerChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_lowercase(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonLowerChars.span().takeOkay(), charIsLowercase)); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsLowercase)); + + ASSERT_FALSE(utf8IsLowercase(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, lowerChars.size()> lowerGenerator{lowerChars.span()}; + auto utf8LowerGenerator = [&]() { return lowerGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8LowerGenerator, utf8IsLowercase)); + + SpanGenerator<char> nonLowerGenerator{nonLowerChars.span().takeOkay()}; + auto utf8NonLowerGenerator = [&]() { return nonLowerGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonLowerGenerator, utf8IsLowercase)); } TEST(Utf8Test, Utf8IsUpper) @@ -467,153 +343,61 @@ TEST(Utf8Test, Utf8IsUpper) Array<char, numUpperChars> upperChars{}; copyMem<numUpperChars>(upperChars, upperCharLiteral); - ASSERT_TRUE(allOf(upperChars, ext_lib_char_is_uppercase)); - - auto upperSetResult{StaticSet<char, numUpperChars>::makeFromArray(upperChars)}; - ASSERT_TRUE(upperSetResult.isOkay()); - auto upperSet{std::move(upperSetResult.getOkay())}; + ASSERT_TRUE(allOf(upperChars.span(), charIsUppercase)); constexpr size_t numNonUpperChars = validAsciiSize - numUpperChars; - FixedVector<char, numNonUpperChars> nonUpperChars{}; + Vector<char> nonUpperChars{}; for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!upperSet.isKey(idx)) { - ASSERT_TRUE(nonUpperChars.pushBack(idx)); + if (!charIsUppercase(idx)) { + ASSERT_EQ(nonUpperChars.pushBack(idx), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonUpperChars, ext_lib_char_is_uppercase)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_uppercase)); - - ASSERT_TRUE(allOf( - map(upperChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_uppercase)); - ASSERT_FALSE(anyOf( - map(nonUpperChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_uppercase)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_uppercase)); - - ASSERT_TRUE(allOf( - map(upperChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_uppercase)); - ASSERT_FALSE(anyOf( - map(nonUpperChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_uppercase)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_uppercase)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_uppercase(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_uppercase(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_uppercase(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_uppercase(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(upperChars, [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_uppercase(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonUpperChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_uppercase(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonUpperChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_uppercase(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonUpperChars.span().takeOkay(), charIsUppercase)); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsUppercase)); + + ASSERT_FALSE(utf8IsUppercase(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, upperChars.size()> upperGenerator{upperChars.span()}; + auto utf8UpperGenerator = [&]() { return upperGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8UpperGenerator, utf8IsUppercase)); + + SpanGenerator<char> nonUpperGenerator{nonUpperChars.span().takeOkay()}; + auto utf8NonUpperGenerator = [&]() { return nonUpperGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonUpperGenerator, utf8IsUppercase)); } TEST(Utf8Test, Utf8IsDigit) { constexpr size_t numDigitChars = 10; - Array<char, numDigitChars + 1> digitCharLiteral{"0123456789"}; + Array<char, numDigitChars + 1> digitCharLiteral{DECIMAL_CHARS}; Array<char, numDigitChars> digitChars{}; copyMem<numDigitChars>(digitChars, digitCharLiteral); - ASSERT_TRUE(allOf(digitChars, ext_lib_char_is_digit)); - - auto digitSetResult{StaticSet<char, numDigitChars>::makeFromArray(digitChars)}; - ASSERT_TRUE(digitSetResult.isOkay()); - auto digitSet{std::move(digitSetResult.getOkay())}; + ASSERT_TRUE(allOf(digitChars.span(), charIsDigit)); constexpr size_t numNonDigitChars = validAsciiSize - numDigitChars; - FixedVector<char, numNonDigitChars> nonDigitChars{}; + Vector<char> nonDigitChars{}; for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!digitSet.isKey(idx)) { - ASSERT_TRUE(nonDigitChars.pushBack(idx)); + if (!charIsDigit(idx)) { + ASSERT_EQ(nonDigitChars.pushBack(idx), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonDigitChars, ext_lib_char_is_digit)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_digit)); - - ASSERT_TRUE(allOf( - map(digitChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_digit)); - ASSERT_FALSE(anyOf( - map(nonDigitChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_digit)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_digit)); - - ASSERT_TRUE(allOf( - map(digitChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_digit)); - ASSERT_FALSE(anyOf( - map(nonDigitChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_digit)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_digit)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_digit(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_digit(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_digit(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_digit(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(digitChars, [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_digit(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonDigitChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_digit(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonDigitChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_digit(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonDigitChars.span().takeOkay(), charIsDigit)); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsDigit)); + + ASSERT_FALSE(utf8IsDigit(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, digitChars.size()> digitGenerator{digitChars.span()}; + auto utf8DigitGenerator = [&]() { return digitGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8DigitGenerator, utf8IsDigit)); + + SpanGenerator<char> nonDigitGenerator{nonDigitChars.span().takeOkay()}; + auto utf8NonDigitGenerator = [&]() { return nonDigitGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonDigitGenerator, utf8IsDigit)); } TEST(Utf8Test, Utf8IsHexDigit) @@ -623,147 +407,61 @@ TEST(Utf8Test, Utf8IsHexDigit) Array<char, numHexDigitChars> hexDigitChars{}; copyMem<numHexDigitChars>(hexDigitChars, hexDigitCharLiteral); - ASSERT_TRUE(allOf(hexDigitChars, ext_lib_char_is_hex_digit)); - - auto hexDigitSetResult{StaticSet<char, numHexDigitChars>::makeFromArray(hexDigitChars)}; - ASSERT_TRUE(hexDigitSetResult.isOkay()); - auto hexDigitSet{std::move(hexDigitSetResult.getOkay())}; + ASSERT_TRUE(allOf(hexDigitChars.span(), charIsHexDigit)); constexpr size_t numNonHexDigitChars = validAsciiSize - numHexDigitChars; - FixedVector<char, numNonHexDigitChars> nonHexDigitChars{}; + Vector<char> nonHexDigitChars{}; for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!hexDigitSet.isKey(idx)) { - ASSERT_TRUE(nonHexDigitChars.pushBack(idx)); + if (!charIsHexDigit(idx)) { + ASSERT_EQ(nonHexDigitChars.pushBack(idx), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonHexDigitChars, ext_lib_char_is_hex_digit)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_hex_digit)); - - ASSERT_TRUE(allOf( - map(hexDigitChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_hex_digit)); - ASSERT_FALSE(anyOf( - map(nonHexDigitChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_hex_digit)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_hex_digit)); - - ASSERT_TRUE(allOf( - map(hexDigitChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_hex_digit)); - ASSERT_FALSE(anyOf( - map(nonHexDigitChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_hex_digit)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_hex_digit)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_hex_digit(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_hex_digit(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_hex_digit(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_hex_digit(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(hexDigitChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_hex_digit(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonHexDigitChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_hex_digit(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonHexDigitChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_hex_digit(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonHexDigitChars.span().takeOkay(), charIsHexDigit)); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsHexDigit)); + + ASSERT_FALSE(utf8IsHexDigit(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, hexDigitChars.size()> hexDigitGenerator{hexDigitChars.span()}; + auto utf8HexDigitGenerator = [&]() { return hexDigitGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8HexDigitGenerator, utf8IsHexDigit)); + + SpanGenerator<char> nonHexDigitGenerator{nonHexDigitChars.span().takeOkay()}; + auto utf8NonHexDigitGenerator = [&]() { return nonHexDigitGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonHexDigitGenerator, utf8IsHexDigit)); } TEST(Utf8Test, Utf8IsControl) { - auto controlChars = generateIndexArray<Array, char, numControlChars>([](int idx) { return static_cast<char>(idx); }); + Iota<char> controlArrayGenerator{0, 1, numControlChars}; + auto controlChars = generate([]() { return Array<char, numControlChars>{}; }, controlArrayGenerator); constexpr const char deleteChar = 0x7F; controlChars.back() = deleteChar; - ASSERT_TRUE(allOf(controlChars, ext_lib_char_is_control)); - - constexpr size_t numNonControlChars = 256 - numControlChars; - auto nonControlChars = generateIndexArray<Array, char, numControlChars>([](int idx) { - return static_cast<char>(idx + printableCharOffset); - }); - ASSERT_FALSE(anyOf(nonControlChars, ext_lib_char_is_control)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_control)); - - ASSERT_TRUE(allOf( - map(controlChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_control)); - ASSERT_FALSE(anyOf( - map(nonControlChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_control)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_control)); - - ASSERT_TRUE(allOf( - map(controlChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_control)); - ASSERT_FALSE(anyOf( - map(nonControlChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_control)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_control)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_control(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_control(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_control(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_control(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(controlChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_control(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonControlChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_control(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonControlChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_control(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_TRUE(allOf(controlChars.span(), charIsControl)); + + constexpr size_t numNonControlChars = INT8_MAX + 1 - numControlChars; + Vector<char> nonControlChars{}; + ASSERT_EQ(nonControlChars.reserve(numNonControlChars), FudStatus::Success); + for (auto idx = numControlChars - 1; idx < deleteChar; ++idx) { + ASSERT_EQ(nonControlChars.pushBack(idx), FudStatus::Success); + } + ASSERT_FALSE(anyOf(nonControlChars.span().takeOkay(), charIsControl)); + ASSERT_TRUE(allOf(nonControlChars.span().takeOkay(), charIsAscii)); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsControl)); + + ASSERT_FALSE(utf8IsControl(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, controlChars.size()> controlGenerator{controlChars.span()}; + auto utf8ControlGenerator = [&]() { return controlGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8ControlGenerator, utf8IsControl)); + + SpanGenerator<char> nonControlGenerator{nonControlChars.span().takeOkay()}; + auto utf8NonControlGenerator = [&]() { return nonControlGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonControlGenerator, utf8IsControl)); } TEST(Utf8Test, Utf8IsGraphical) @@ -773,311 +471,137 @@ TEST(Utf8Test, Utf8IsGraphical) Array<char, numGraphicalChars> graphicalChars{}; copyMem<numGraphicalChars>(graphicalChars, graphicalCharLiteral); - ASSERT_TRUE(allOf(graphicalChars, ext_lib_char_is_graphical)); - - auto graphicalSetResult{StaticSet<char, numGraphicalChars>::makeFromArray(graphicalChars)}; - ASSERT_TRUE(graphicalSetResult.isOkay()); - auto graphicalSet{std::move(graphicalSetResult.getOkay())}; + ASSERT_TRUE(allOf(graphicalChars.span(), charIsGraphical)); constexpr size_t numNonGraphicalChars = validAsciiSize - numGraphicalChars; - FixedVector<char, numNonGraphicalChars> nonGraphicalChars{}; - for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!graphicalSet.isKey(idx)) { - ASSERT_TRUE(nonGraphicalChars.pushBack(idx)); + Vector<char> nonGraphicalChars{}; + ASSERT_EQ(nonGraphicalChars.reserve(numNonGraphicalChars), FudStatus::Success); + for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) { + if (!charIsGraphical(static_cast<char>(idx))) { + ASSERT_EQ(nonGraphicalChars.pushBack(static_cast<char>(idx)), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonGraphicalChars, ext_lib_char_is_graphical)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_graphical)); - - ASSERT_TRUE(allOf( - map(graphicalChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_graphical)); - ASSERT_FALSE(anyOf( - map(nonGraphicalChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_graphical)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_graphical)); - - ASSERT_TRUE(allOf( - map(graphicalChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_graphical)); - ASSERT_FALSE(anyOf( - map(nonGraphicalChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_graphical)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_graphical)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_graphical(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_graphical(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_graphical(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_graphical(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(graphicalChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_graphical(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonGraphicalChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_graphical(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonGraphicalChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_graphical(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonGraphicalChars.span().takeOkay(), charIsGraphical)); + ASSERT_TRUE(allOf(nonGraphicalChars.span().takeOkay(), charIsAscii)); + ASSERT_EQ(nonGraphicalChars.size() + graphicalChars.size(), INT8_MAX + 1); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsGraphical)); + + ASSERT_FALSE(utf8IsGraphical(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, graphicalChars.size()> graphicalGenerator{graphicalChars.span()}; + auto utf8GraphicalGenerator = [&]() { return graphicalGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8GraphicalGenerator, utf8IsGraphical)); + + SpanGenerator<char> nonGraphicalGenerator{nonGraphicalChars.span().takeOkay()}; + auto utf8NonGraphicalGenerator = [&]() { return nonGraphicalGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonGraphicalGenerator, utf8IsGraphical)); } TEST(Utf8Test, Utf8IsSpace) { - constexpr size_t numSpaceChars = sizeof(" \t\v\r\n") - 1; - Array<char, numSpaceChars + 1> spaceCharLiteral{" \t\v\r\n"}; + constexpr size_t numSpaceChars = sizeof(SPACE_CHARS) - 1; + Array<char, numSpaceChars + 1> spaceCharLiteral{SPACE_CHARS}; Array<char, numSpaceChars> spaceChars{}; copyMem<numSpaceChars>(spaceChars, spaceCharLiteral); - ASSERT_TRUE(allOf(spaceChars, ext_lib_char_is_space)); - - auto spaceSetResult{StaticSet<char, numSpaceChars>::makeFromArray(spaceChars)}; - ASSERT_TRUE(spaceSetResult.isOkay()); - auto spaceSet{std::move(spaceSetResult.getOkay())}; + ASSERT_TRUE(allOf(spaceChars.span(), charIsSpace)); constexpr size_t numNonSpaceChars = validAsciiSize - numSpaceChars; - FixedVector<char, numNonSpaceChars> nonSpaceChars{}; - for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!spaceSet.isKey(idx)) { - ASSERT_TRUE(nonSpaceChars.pushBack(idx)); + Vector<char> nonSpaceChars{}; + ASSERT_EQ(nonSpaceChars.reserve(numNonSpaceChars), FudStatus::Success); + for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) { + if (!charIsSpace(static_cast<char>(idx))) { + ASSERT_EQ(nonSpaceChars.pushBack(static_cast<char>(idx)), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonSpaceChars, ext_lib_char_is_space)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_space)); - - ASSERT_TRUE(allOf( - map(spaceChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_space)); - ASSERT_FALSE(anyOf( - map(nonSpaceChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_space)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_space)); - - ASSERT_TRUE(allOf( - map(spaceChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_space)); - ASSERT_FALSE(anyOf( - map(nonSpaceChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_space)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_space)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_space(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_space(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_space(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_space(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(spaceChars, [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_space(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonSpaceChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_space(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonSpaceChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_space(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonSpaceChars.span().takeOkay(), charIsSpace)); + ASSERT_TRUE(allOf(nonSpaceChars.span().takeOkay(), charIsAscii)); + ASSERT_EQ(nonSpaceChars.size() + spaceChars.size(), INT8_MAX + 1); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsSpace)); + + ASSERT_FALSE(utf8IsSpace(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, spaceChars.size()> spaceGenerator{spaceChars.span()}; + auto utf8SpaceGenerator = [&]() { return spaceGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8SpaceGenerator, utf8IsSpace)); + + SpanGenerator<char> nonSpaceGenerator{nonSpaceChars.span().takeOkay()}; + auto utf8NonSpaceGenerator = [&]() { return nonSpaceGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonSpaceGenerator, utf8IsSpace)); } TEST(Utf8Test, Utf8IsBlank) { - constexpr size_t numBlankChars = sizeof(" \t") - 1; - Array<char, numBlankChars + 1> blankCharLiteral{" \t"}; + constexpr size_t numBlankChars = sizeof(BLANK_CHARS) - 1; + Array<char, numBlankChars + 1> blankCharLiteral{BLANK_CHARS}; Array<char, numBlankChars> blankChars{}; copyMem<numBlankChars>(blankChars, blankCharLiteral); - ASSERT_TRUE(allOf(blankChars, ext_lib_char_is_blank)); - - auto blankSetResult{StaticSet<char, numBlankChars>::makeFromArray(blankChars)}; - ASSERT_TRUE(blankSetResult.isOkay()); - auto blankSet{std::move(blankSetResult.getOkay())}; + ASSERT_TRUE(allOf(blankChars.span(), charIsBlank)); constexpr size_t numNonBlankChars = validAsciiSize - numBlankChars; - FixedVector<char, numNonBlankChars> nonBlankChars{}; - for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!blankSet.isKey(idx)) { - ASSERT_TRUE(nonBlankChars.pushBack(idx)); + Vector<char> nonBlankChars{}; + ASSERT_EQ(nonBlankChars.reserve(numNonBlankChars), FudStatus::Success); + for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) { + if (!charIsBlank(static_cast<char>(idx))) { + ASSERT_EQ(nonBlankChars.pushBack(static_cast<char>(idx)), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonBlankChars, ext_lib_char_is_blank)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_blank)); - - ASSERT_TRUE(allOf( - map(blankChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_blank)); - ASSERT_FALSE(anyOf( - map(nonBlankChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_blank)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_blank)); - - ASSERT_TRUE(allOf( - map(blankChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_blank)); - ASSERT_FALSE(anyOf( - map(nonBlankChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_blank)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_blank)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_blank(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_blank(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_blank(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_blank(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(blankChars, [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_blank(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonBlankChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_blank(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonBlankChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_blank(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonBlankChars.span().takeOkay(), charIsBlank)); + ASSERT_TRUE(allOf(nonBlankChars.span().takeOkay(), charIsAscii)); + ASSERT_EQ(nonBlankChars.size() + blankChars.size(), INT8_MAX + 1); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsBlank)); + + ASSERT_FALSE(utf8IsBlank(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, blankChars.size()> blankGenerator{blankChars.span()}; + auto utf8BlankGenerator = [&]() { return blankGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8BlankGenerator, utf8IsBlank)); + + SpanGenerator<char> nonBlankGenerator{nonBlankChars.span().takeOkay()}; + auto utf8NonBlankGenerator = [&]() { return nonBlankGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonBlankGenerator, utf8IsBlank)); } TEST(Utf8Test, Utf8IsPrintable) { - constexpr size_t numPrintableChars = validAsciiSize - numControlChars; - auto printableChars = generateIndexArray<Array, char, numPrintableChars>([](int idx) { - return static_cast<char>(idx + printableCharOffset); - }); - - ASSERT_TRUE(allOf(printableChars, ext_lib_char_is_printable)); + constexpr size_t numPrintableChars = sizeof(PRINTABLE_CHARS) - 1; + Array<char, numPrintableChars + 1> printableCharLiteral{PRINTABLE_CHARS}; + Array<char, numPrintableChars> printableChars{}; + copyMem<numPrintableChars>(printableChars, printableCharLiteral); - auto printableSetResult{StaticSet<char, numPrintableChars>::makeFromArray(printableChars)}; - ASSERT_TRUE(printableSetResult.isOkay()); - auto printableSet{std::move(printableSetResult.getOkay())}; + ASSERT_TRUE(allOf(printableChars.span(), charIsPrintable)); constexpr size_t numNonPrintableChars = validAsciiSize - numPrintableChars; - FixedVector<char, numNonPrintableChars> nonPrintableChars{}; - for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!printableSet.isKey(idx)) { - ASSERT_TRUE(nonPrintableChars.pushBack(idx)); + Vector<char> nonPrintableChars{}; + ASSERT_EQ(nonPrintableChars.reserve(numNonPrintableChars), FudStatus::Success); + for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) { + if (!charIsPrintable(static_cast<char>(idx))) { + ASSERT_EQ(nonPrintableChars.pushBack(static_cast<char>(idx)), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonPrintableChars, ext_lib_char_is_printable)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_printable)); - - ASSERT_TRUE(allOf( - map(printableChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_printable)); - ASSERT_FALSE(anyOf( - map(nonPrintableChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_printable)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_printable)); - - ASSERT_TRUE(allOf( - map(printableChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_printable)); - ASSERT_FALSE(anyOf( - map(nonPrintableChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_printable)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_printable)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_printable(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_printable(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_printable(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_printable(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(printableChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_printable(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonPrintableChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_printable(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonPrintableChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_printable(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonPrintableChars.span().takeOkay(), charIsPrintable)); + ASSERT_TRUE(allOf(nonPrintableChars.span().takeOkay(), charIsAscii)); + ASSERT_EQ(nonPrintableChars.size() + printableChars.size(), INT8_MAX + 1); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsPrintable)); + + ASSERT_FALSE(utf8IsPrintable(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, printableChars.size()> printableGenerator{printableChars.span()}; + auto utf8PrintableGenerator = [&]() { return printableGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8PrintableGenerator, utf8IsPrintable)); + + SpanGenerator<char> nonPrintableGenerator{nonPrintableChars.span().takeOkay()}; + auto utf8NonPrintableGenerator = [&]() { return nonPrintableGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonPrintableGenerator, utf8IsPrintable)); } TEST(Utf8Test, Utf8IsPunctuation) @@ -1087,77 +611,32 @@ TEST(Utf8Test, Utf8IsPunctuation) Array<char, numPunctuationChars> punctuationChars{}; copyMem<numPunctuationChars>(punctuationChars, punctuationCharLiteral); - ASSERT_TRUE(allOf(punctuationChars, ext_lib_char_is_punctuation)); - - auto punctuationSetResult{StaticSet<char, numPunctuationChars>::makeFromArray(punctuationChars)}; - ASSERT_TRUE(punctuationSetResult.isOkay()); - auto punctuationSet{std::move(punctuationSetResult.getOkay())}; + ASSERT_TRUE(allOf(punctuationChars.span(), charIsPunctuation)); constexpr size_t numNonPunctuationChars = validAsciiSize - numPunctuationChars; - FixedVector<char, numNonPunctuationChars> nonPunctuationChars{}; - for (char idx = 0; idx < INT8_MAX; ++idx) { - if (!punctuationSet.isKey(idx)) { - ASSERT_TRUE(nonPunctuationChars.pushBack(idx)); + Vector<char> nonPunctuationChars{}; + ASSERT_EQ(nonPunctuationChars.reserve(numNonPunctuationChars), FudStatus::Success); + for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) { + if (!charIsPunctuation(static_cast<char>(idx))) { + ASSERT_EQ(nonPunctuationChars.pushBack(static_cast<char>(idx)), FudStatus::Success); } } - ASSERT_FALSE(anyOf(nonPunctuationChars, ext_lib_char_is_punctuation)); - - auto invalidAsciiChars = generateInvalidAsciiChars(); - ASSERT_FALSE(anyOf(invalidAsciiChars, ext_lib_char_is_punctuation)); - - ASSERT_TRUE(allOf( - map(punctuationChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_punctuation)); - ASSERT_FALSE(anyOf( - map(nonPunctuationChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_punctuation)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_punctuation)); - - ASSERT_TRUE(allOf( - map(punctuationChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_punctuation)); - ASSERT_FALSE(anyOf( - map(nonPunctuationChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_punctuation)); - ASSERT_FALSE(anyOf( - map(invalidAsciiChars, [](auto input) { return ExtUtf8Char4{static_cast<utf8>(input)}; }), - ext_lib_char4_is_punctuation)); - - Utf8 utf8{invalidAscii}; - bool isAscii = false; - ASSERT_EQ(ext_lib_utf8_is_punctuation(nullptr, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_punctuation(&utf8, nullptr), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_punctuation(nullptr, &isAscii), ExtNullPointer); - ASSERT_EQ(ext_lib_utf8_is_punctuation(&utf8, &isAscii), ExtInvalidInput); - ASSERT_FALSE(isAscii); - - ASSERT_TRUE(allOf( - map(punctuationChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_punctuation(&utf8Letter, &predicate); - return isPredicateStatus == ExtSuccess && predicate; - })); - ASSERT_FALSE(anyOf( - map(nonPunctuationChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_punctuation(&utf8Letter, &predicate); - return isPredicateStatus != ExtSuccess || predicate; - })); - ASSERT_FALSE(allOf( - map(nonPunctuationChars, - [](char letter) { return FudUtf8::makeUtf8(ExtUtf8Char4{static_cast<utf8>(letter)}); }), - [](auto& utf8Letter) { - bool predicate = false; - auto isPredicateStatus = ext_lib_utf8_is_punctuation(&utf8Letter, &predicate); - return isPredicateStatus == ExtInvalidInput && !predicate; - })); + ASSERT_FALSE(anyOf(nonPunctuationChars.span().takeOkay(), charIsPunctuation)); + ASSERT_TRUE(allOf(nonPunctuationChars.span().takeOkay(), charIsAscii)); + ASSERT_EQ(nonPunctuationChars.size() + punctuationChars.size(), INT8_MAX + 1); + + auto invalidAsciiChars = invalidAsciiGenerator(); + ASSERT_FALSE(anyOf(invalidAsciiChars, charIsPunctuation)); + + ASSERT_FALSE(utf8IsPunctuation(FudUtf8{Ascii{invalidAscii}})); + + SpanGenerator<char, punctuationChars.size()> punctuationGenerator{punctuationChars.span()}; + auto utf8PunctuationGenerator = [&]() { return punctuationGenerator().map(toUtf8<uint16_t>); }; + ASSERT_TRUE(allOf(utf8PunctuationGenerator, utf8IsPunctuation)); + + SpanGenerator<char> nonPunctuationGenerator{nonPunctuationChars.span().takeOkay()}; + auto utf8NonPunctuationGenerator = [&]() { return nonPunctuationGenerator().map(toUtf8<uint16_t>); }; + ASSERT_FALSE(anyOf(utf8NonPunctuationGenerator, utf8IsPunctuation)); } -#endif } // namespace fud |