mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-01-07 22:30:13 -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
file Copyright.txt or https://cmake.org/licensing for details. */
#include <cm/string_view>
#include <stdio.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;
printf("[");
for (; *d; ++d) {
for (char c : s) {
if (started) {
printf(",");
}
started = true;
printf("0x%02X", static_cast<int>(*d));
printf("0x%02X", static_cast<unsigned char>(c));
}
printf("]");
}
struct test_utf8_entry
{
int n;
test_utf8_char str;
unsigned int chr;
};
static test_utf8_entry const good_entry[] = {
{ 1, "\x20\x00\x00\x00", 0x0020 }, /* Space. */
{ 2, "\xC2\xA9\x00\x00", 0x00A9 }, /* Copyright. */
{ 3, "\xE2\x80\x98\x00", 0x2018 }, /* Open-single-quote. */
{ 3, "\xE2\x80\x99\x00", 0x2019 }, /* Close-single-quote. */
{ 4, "\xF0\xA3\x8E\xB4", 0x233B4 }, /* Example from RFC 3629. */
{ 3, "\xED\x80\x80\x00", 0xD000 }, /* Valid 0xED prefixed codepoint. */
{ 4, "\xF4\x8F\xBF\xBF", 0x10FFFF }, /* Highest valid RFC codepoint. */
{ 0, { 0, 0, 0, 0, 0 }, 0 }
{ "\x20", 0x0020 }, /* Space. */
{ "\xC2\xA9", 0x00A9 }, /* Copyright. */
{ "\xE2\x80\x98", 0x2018 }, /* Open-single-quote. */
{ "\xE2\x80\x99", 0x2019 }, /* Close-single-quote. */
{ "\xF0\xA3\x8E\xB4", 0x233B4 }, /* Example from RFC 3629. */
{ "\xED\x80\x80", 0xD000 }, /* Valid 0xED prefixed codepoint. */
{ "\xF4\x8F\xBF\xBF", 0x10FFFF }, /* Highest valid RFC codepoint. */
{ {}, 0 }
};
static test_utf8_char const bad_chars[] = {
"\x80\x00\x00\x00", /* Leading continuation byte. */
"\xC0\x80\x00\x00", /* Overlong encoding. */
"\xC1\x80\x00\x00", /* Overlong encoding. */
"\xC2\x00\x00\x00", /* Missing continuation byte. */
"\xE0\x00\x00\x00", /* Missing continuation bytes. */
"\xE0\x80\x80\x00", /* Overlong encoding. */
"\x80", /* Leading continuation byte. */
"\xC0\x80", /* Overlong encoding. */
"\xC1\x80", /* Overlong encoding. */
"\xC2", /* Missing continuation byte. */
"\xE0", /* Missing continuation bytes. */
"\xE0\x80\x80", /* Overlong encoding. */
"\xF0\x80\x80\x80", /* Overlong encoding. */
"\xED\xA0\x80\x00", /* UTF-16 surrogate half. */
"\xED\xBF\xBF\x00", /* UTF-16 surrogate half. */
"\xED\xA0\x80", /* UTF-16 surrogate half. */
"\xED\xBF\xBF", /* UTF-16 surrogate half. */
"\xF4\x90\x80\x80", /* Lowest out-of-range codepoint. */
"\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 };
@@ -71,49 +61,50 @@ static char const* bad_strings[] = {
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");
test_utf8_char_print(c);
printf(" (%s) ", c);
byte_array_print(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");
test_utf8_char_print(c);
byte_array_print(c);
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;
if (const char* e =
cm_utf8_decode_character(entry.str, entry.str + 4, &uc)) {
int used = static_cast<int>(e - entry.str);
cm_utf8_decode_character(s.data(), s.data() + s.size(), &uc)) {
int used = static_cast<int>(e - s.data());
if (uc != entry.chr) {
report_good(false, entry.str);
report_good(false, s);
printf("expected 0x%04X, got 0x%04X\n", entry.chr, uc);
return false;
}
if (used != entry.n) {
report_good(false, entry.str);
printf("had %d bytes, used %d\n", entry.n, used);
if (used != int(s.size())) {
report_good(false, s);
printf("had %d bytes, used %d\n", int(s.size()), used);
return false;
}
report_good(true, entry.str);
report_good(true, s);
printf("got 0x%04X\n", uc);
return true;
}
report_good(false, entry.str);
report_good(false, s);
printf("failed\n");
return false;
}
static bool decode_bad(test_utf8_char const s)
static bool decode_bad(test_utf8_char s)
{
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) {
report_bad(false, s);
printf("expected failure, got 0x%04X\n", uc);
@@ -124,23 +115,23 @@ static bool decode_bad(test_utf8_char const s)
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");
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");
byte_array_print(s);
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) {
report_valid(false, s);
printf("expected valid, reported as invalid\n");
@@ -151,9 +142,9 @@ static bool is_valid(const char* s)
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) {
report_invalid(false, s);
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 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)) {
result = 1;
}
@@ -175,7 +166,7 @@ int testUTF8(int /*unused*/, char* /*unused*/[])
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)) {
result = 1;
}