mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-02-06 23:29:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

testUTF8: Improve using string_view

Browse Source
This commit is contained in:
Vitaly Stakhovsky
2023-07-30 15:00:00 -04:00
parent 49e2a4a0a7
commit 3ce4e9523c
1 changed files with 49 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
Tests/CMakeLib/testUTF8.cxx
View File

@@ -1,67 +1,57 @@
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */ file Copyright.txt or https://cmake.org/licensing for details. */
#include <cm/string_view>
#include <stdio.h> #include <stdio.h>
#include <cm_utf8.h> #include <cm_utf8.h>
typedef char test_utf8_char[5]; using test_utf8_char = const cm::string_view;
static void test_utf8_char_print(test_utf8_char const c) static void byte_array_print(test_utf8_char s)
{ {
unsigned char const* d = reinterpret_cast<unsigned char const*>(c);
#ifndef __clang_analyzer__ // somehow thinks arguments are not initialized
printf("[0x%02X,0x%02X,0x%02X,0x%02X]", static_cast<int>(d[0]),
static_cast<int>(d[1]), static_cast<int>(d[2]),
static_cast<int>(d[3]));
#endif
}
static void byte_array_print(char const* s)
{
unsigned char const* d = reinterpret_cast<unsigned char const*>(s);
bool started = false; bool started = false;
printf("["); printf("[");
for (; *d; ++d) { for (char c : s) {
if (started) { if (started) {
printf(","); printf(",");
} }
started = true; started = true;
printf("0x%02X", static_cast<int>(*d)); printf("0x%02X", static_cast<unsigned char>(c));
} }
printf("]"); printf("]");
} }
struct test_utf8_entry struct test_utf8_entry
{ {
int n;
test_utf8_char str; test_utf8_char str;
unsigned int chr; unsigned int chr;
}; };
static test_utf8_entry const good_entry[] = { static test_utf8_entry const good_entry[] = {
{ 1, "\x20\x00\x00\x00", 0x0020 }, /* Space. */ { "\x20", 0x0020 }, /* Space. */
{ 2, "\xC2\xA9\x00\x00", 0x00A9 }, /* Copyright. */ { "\xC2\xA9", 0x00A9 }, /* Copyright. */
{ 3, "\xE2\x80\x98\x00", 0x2018 }, /* Open-single-quote. */ { "\xE2\x80\x98", 0x2018 }, /* Open-single-quote. */
{ 3, "\xE2\x80\x99\x00", 0x2019 }, /* Close-single-quote. */ { "\xE2\x80\x99", 0x2019 }, /* Close-single-quote. */
{ 4, "\xF0\xA3\x8E\xB4", 0x233B4 }, /* Example from RFC 3629. */ { "\xF0\xA3\x8E\xB4", 0x233B4 }, /* Example from RFC 3629. */
{ 3, "\xED\x80\x80\x00", 0xD000 }, /* Valid 0xED prefixed codepoint. */ { "\xED\x80\x80", 0xD000 }, /* Valid 0xED prefixed codepoint. */
{ 4, "\xF4\x8F\xBF\xBF", 0x10FFFF }, /* Highest valid RFC codepoint. */ { "\xF4\x8F\xBF\xBF", 0x10FFFF }, /* Highest valid RFC codepoint. */
{ 0, { 0, 0, 0, 0, 0 }, 0 } { {}, 0 }
}; };
static test_utf8_char const bad_chars[] = { static test_utf8_char const bad_chars[] = {
"\x80\x00\x00\x00", /* Leading continuation byte. */ "\x80", /* Leading continuation byte. */
"\xC0\x80\x00\x00", /* Overlong encoding. */ "\xC0\x80", /* Overlong encoding. */
"\xC1\x80\x00\x00", /* Overlong encoding. */ "\xC1\x80", /* Overlong encoding. */
"\xC2\x00\x00\x00", /* Missing continuation byte. */ "\xC2", /* Missing continuation byte. */
"\xE0\x00\x00\x00", /* Missing continuation bytes. */ "\xE0", /* Missing continuation bytes. */
"\xE0\x80\x80\x00", /* Overlong encoding. */ "\xE0\x80\x80", /* Overlong encoding. */
"\xF0\x80\x80\x80", /* Overlong encoding. */ "\xF0\x80\x80\x80", /* Overlong encoding. */
"\xED\xA0\x80\x00", /* UTF-16 surrogate half. */ "\xED\xA0\x80", /* UTF-16 surrogate half. */
"\xED\xBF\xBF\x00", /* UTF-16 surrogate half. */ "\xED\xBF\xBF", /* UTF-16 surrogate half. */
"\xF4\x90\x80\x80", /* Lowest out-of-range codepoint. */ "\xF4\x90\x80\x80", /* Lowest out-of-range codepoint. */
"\xF5\x80\x80\x80", /* Prefix forces out-of-range codepoints. */ "\xF5\x80\x80\x80", /* Prefix forces out-of-range codepoints. */
{ 0, 0, 0, 0, 0 } {}
}; };
static char const* good_strings[] = { "", "ASCII", "\xC2\xA9 Kitware", 0 }; static char const* good_strings[] = { "", "ASCII", "\xC2\xA9 Kitware", 0 };
@@ -71,49 +61,50 @@ static char const* bad_strings[] = {
0 0
}; };
static void report_good(bool passed, test_utf8_char const c) static void report_good(bool passed, test_utf8_char c)
{ {
printf("%s: decoding good ", passed ? "pass" : "FAIL"); printf("%s: decoding good ", passed ? "pass" : "FAIL");
test_utf8_char_print(c); byte_array_print(c);
printf(" (%s) ", c); printf(" (%s) ", c.data());
} }
static void report_bad(bool passed, test_utf8_char const c) static void report_bad(bool passed, test_utf8_char c)
{ {
printf("%s: decoding bad ", passed ? "pass" : "FAIL"); printf("%s: decoding bad ", passed ? "pass" : "FAIL");
test_utf8_char_print(c); byte_array_print(c);
printf(" "); printf(" ");
} }
static bool decode_good(test_utf8_entry const entry) static bool decode_good(test_utf8_entry const& entry)
{ {
const auto& s = entry.str;
unsigned int uc; unsigned int uc;
if (const char* e = if (const char* e =
cm_utf8_decode_character(entry.str, entry.str + 4, &uc)) { cm_utf8_decode_character(s.data(), s.data() + s.size(), &uc)) {
int used = static_cast<int>(e - entry.str); int used = static_cast<int>(e - s.data());
if (uc != entry.chr) { if (uc != entry.chr) {
report_good(false, entry.str); report_good(false, s);
printf("expected 0x%04X, got 0x%04X\n", entry.chr, uc); printf("expected 0x%04X, got 0x%04X\n", entry.chr, uc);
return false; return false;
} }
if (used != entry.n) { if (used != int(s.size())) {
report_good(false, entry.str); report_good(false, s);
printf("had %d bytes, used %d\n", entry.n, used); printf("had %d bytes, used %d\n", int(s.size()), used);
return false; return false;
} }
report_good(true, entry.str); report_good(true, s);
printf("got 0x%04X\n", uc); printf("got 0x%04X\n", uc);
return true; return true;
} }
report_good(false, entry.str); report_good(false, s);
printf("failed\n"); printf("failed\n");
return false; return false;
} }
static bool decode_bad(test_utf8_char const s) static bool decode_bad(test_utf8_char s)
{ {
unsigned int uc = 0xFFFFu; unsigned int uc = 0xFFFFu;
const char* e = cm_utf8_decode_character(s, s + 4, &uc); const char* e = cm_utf8_decode_character(s.data(), s.data() + s.size(), &uc);
if (e) { if (e) {
report_bad(false, s); report_bad(false, s);
printf("expected failure, got 0x%04X\n", uc); printf("expected failure, got 0x%04X\n", uc);
@@ -124,23 +115,23 @@ static bool decode_bad(test_utf8_char const s)
return true; return true;
} }
static void report_valid(bool passed, char const* s) static void report_valid(bool passed, test_utf8_char s)
{ {
printf("%s: validity good ", passed ? "pass" : "FAIL"); printf("%s: validity good ", passed ? "pass" : "FAIL");
byte_array_print(s); byte_array_print(s);
printf(" (%s) ", s); printf(" (%s) ", s.data());
} }
static void report_invalid(bool passed, char const* s) static void report_invalid(bool passed, test_utf8_char s)
{ {
printf("%s: validity bad ", passed ? "pass" : "FAIL"); printf("%s: validity bad ", passed ? "pass" : "FAIL");
byte_array_print(s); byte_array_print(s);
printf(" "); printf(" ");
} }
static bool is_valid(const char* s) static bool is_valid(test_utf8_char s)
{ {
bool valid = cm_utf8_is_valid(s) != 0; bool valid = cm_utf8_is_valid(s.data()) != 0;
if (!valid) { if (!valid) {
report_valid(false, s); report_valid(false, s);
printf("expected valid, reported as invalid\n"); printf("expected valid, reported as invalid\n");
@@ -151,9 +142,9 @@ static bool is_valid(const char* s)
return true; return true;
} }
static bool is_invalid(const char* s) static bool is_invalid(test_utf8_char s)
{ {
bool valid = cm_utf8_is_valid(s) != 0; bool valid = cm_utf8_is_valid(s.data()) != 0;
if (valid) { if (valid) {
report_invalid(false, s); report_invalid(false, s);
printf("expected invalid, reported as valid\n"); printf("expected invalid, reported as valid\n");
@@ -167,7 +158,7 @@ static bool is_invalid(const char* s)
int testUTF8(int /*unused*/, char* /*unused*/[]) int testUTF8(int /*unused*/, char* /*unused*/[])
{ {
int result = 0; int result = 0;
for (test_utf8_entry const* e = good_entry; e->n; ++e) { for (test_utf8_entry const* e = good_entry; !e->str.empty(); ++e) {
if (!decode_good(*e)) { if (!decode_good(*e)) {
result = 1; result = 1;
} }
@@ -175,7 +166,7 @@ int testUTF8(int /*unused*/, char* /*unused*/[])
result = 1; result = 1;
} }
} }
for (test_utf8_char const* c = bad_chars; (*c)[0]; ++c) { for (test_utf8_char* c = bad_chars; !(*c).empty(); ++c) {
if (!decode_bad(*c)) { if (!decode_bad(*c)) {
result = 1; result = 1;
} }