From 664763afbbff0c5cab5d418bf39bf68fcd87dc14 Mon Sep 17 00:00:00 2001 From: yyc12345 Date: Tue, 12 Aug 2025 13:05:35 +0800 Subject: [PATCH] test: add testbench for stl, windows and iconv encoding --- testbench/CMakeLists.txt | 7 +- testbench/main_legacy.cpp | 176 -------------------- testbench/shared/literals.cpp | 203 ++++++++++++++++++++++++ testbench/shared/literals.hpp | 64 ++++++++ testbench/yycc/encoding/iconv.cpp | 116 ++++++++++++++ testbench/yycc/encoding/stl.cpp | 56 +++++++ testbench/yycc/encoding/utf_literal.hpp | 0 testbench/yycc/encoding/windows.cpp | 137 ++++++++++++++++ 8 files changed, 582 insertions(+), 177 deletions(-) create mode 100644 testbench/shared/literals.cpp create mode 100644 testbench/shared/literals.hpp create mode 100644 testbench/yycc/encoding/iconv.cpp create mode 100644 testbench/yycc/encoding/stl.cpp delete mode 100644 testbench/yycc/encoding/utf_literal.hpp create mode 100644 testbench/yycc/encoding/windows.cpp diff --git a/testbench/CMakeLists.txt b/testbench/CMakeLists.txt index b5327b1..3665c08 100644 --- a/testbench/CMakeLists.txt +++ b/testbench/CMakeLists.txt @@ -3,6 +3,8 @@ add_executable(YYCCTestbench "") # Setup testbench sources target_sources(YYCCTestbench PRIVATE + shared/literals.cpp + main.cpp yycc/macro/version_cmp.cpp yycc/flag_enum.cpp @@ -16,12 +18,15 @@ PRIVATE yycc/num/op.cpp yycc/num/safe_cast.cpp yycc/num/safe_op.cpp + yycc/encoding/stl.cpp + yycc/encoding/windows.cpp + yycc/encoding/iconv.cpp ) target_sources(YYCCTestbench PRIVATE FILE_SET HEADERS FILES - yycc/encoding/utf_literal.hpp + shared/literals.hpp ) # Setup headers target_include_directories(YYCCTestbench diff --git a/testbench/main_legacy.cpp b/testbench/main_legacy.cpp index 49a32a2..cfad2a2 100644 --- a/testbench/main_legacy.cpp +++ b/testbench/main_legacy.cpp @@ -185,126 +185,6 @@ namespace YYCCTestbench { } - static void StringTestbench() { - // Test Printf - auto test_printf = YYCC::StringHelper::Printf(YYCC_U8("%s == %s"), YYCC_U8("Hello World"), YYCC_U8("Hello, world")); - Assert(test_printf == YYCC_U8("Hello World == Hello, world"), YYCC_U8("YYCC::StringHelper::Printf")); - - // Test Replace - auto test_replace = YYCC::StringHelper::Replace(YYCC_U8("aabbcc"), YYCC_U8("bb"), YYCC_U8("dd")); // normal case - Assert(test_replace == YYCC_U8("aaddcc"), YYCC_U8("YYCC::StringHelper::Replace")); - test_replace = YYCC::StringHelper::Replace(YYCC_U8("aabbcc"), YYCC_U8("zz"), YYCC_U8("yy")); // no replace - Assert(test_replace == YYCC_U8("aabbcc"), YYCC_U8("YYCC::StringHelper::Replace")); - test_replace = YYCC::StringHelper::Replace(YYCC_U8("aabbcc"), YYCC::yycc_u8string_view(), YYCC_U8("zz")); // empty finding - Assert(test_replace == YYCC_U8("aabbcc"), YYCC_U8("YYCC::StringHelper::Replace")); - test_replace = YYCC::StringHelper::Replace(YYCC_U8("aaaabbaa"), YYCC_U8("aa"), YYCC_U8("")); // no replaced string - Assert(test_replace == YYCC_U8("bb"), YYCC_U8("YYCC::StringHelper::Replace")); - test_replace = YYCC::StringHelper::Replace(YYCC_U8("aaxcc"), YYCC_U8("x"), YYCC_U8("yx")); // nested replacing - Assert(test_replace == YYCC_U8("aayxcc"), YYCC_U8("YYCC::StringHelper::Replace")); - test_replace = YYCC::StringHelper::Replace(YYCC::yycc_u8string_view(), YYCC_U8(""), YYCC_U8("xy")); // empty source string - Assert(test_replace == YYCC_U8(""), YYCC_U8("YYCC::StringHelper::Replace")); - - // Test Upper / Lower - auto test_lower = YYCC::StringHelper::Lower(YYCC_U8("LOWER")); - Assert(test_lower == YYCC_U8("lower"), YYCC_U8("YYCC::StringHelper::Lower")); - auto test_upper = YYCC::StringHelper::Upper(YYCC_U8("upper")); - Assert(test_upper == YYCC_U8("UPPER"), YYCC_U8("YYCC::StringHelper::Upper")); - - // Test Join - std::vector test_join_container { - YYCC_U8(""), YYCC_U8("1"), YYCC_U8("2"), YYCC_U8("") - }; - auto test_join = YYCC::StringHelper::Join(test_join_container.begin(), test_join_container.end(), YYCC_U8(", ")); - Assert(test_join == YYCC_U8(", 1, 2, "), YYCC_U8("YYCC::StringHelper::Join")); - - // Test Split - auto test_split = YYCC::StringHelper::Split(YYCC_U8(", 1, 2, "), YYCC_U8(", ")); // normal - Assert(test_split.size() == 4u, YYCC_U8("YYCC::StringHelper::Split")); - Assert(test_split[0] == YYCC_U8(""), YYCC_U8("YYCC::StringHelper::Split")); - Assert(test_split[1] == YYCC_U8("1"), YYCC_U8("YYCC::StringHelper::Split")); - Assert(test_split[2] == YYCC_U8("2"), YYCC_U8("YYCC::StringHelper::Split")); - Assert(test_split[3] == YYCC_U8(""), YYCC_U8("YYCC::StringHelper::Split")); - test_split = YYCC::StringHelper::Split(YYCC_U8("test"), YYCC_U8("-")); // no matched delimiter - Assert(test_split.size() == 1u, YYCC_U8("YYCC::StringHelper::Split")); - Assert(test_split[0] == YYCC_U8("test"), YYCC_U8("YYCC::StringHelper::Split")); - test_split = YYCC::StringHelper::Split(YYCC_U8("test"), YYCC::yycc_u8string_view()); // empty delimiter - Assert(test_split.size() == 1u, YYCC_U8("YYCC::StringHelper::Split")); - Assert(test_split[0] == YYCC_U8("test"), YYCC_U8("YYCC::StringHelper::Split")); - test_split = YYCC::StringHelper::Split(YYCC::yycc_u8string_view(), YYCC_U8("")); // empty source string - Assert(test_split.size() == 1u, YYCC_U8("YYCC::StringHelper::Split")); - Assert(test_split[0].empty(), YYCC_U8("YYCC::StringHelper::Split")); - - } - - static void ParserTestbench() { - - // Test success TryParse -#define TEST_MACRO(type_t, value, string_value, ...) { \ - YYCC::yycc_u8string cache_string(YYCC_U8(string_value)); \ - type_t cache; \ - Assert(YYCC::ParserHelper::TryParse(cache_string, cache, ##__VA_ARGS__) && cache == value, YYCC_U8("YYCC::StringHelper::TryParse<" #type_t ">")); \ -} - - TEST_MACRO(int8_t, INT8_C(-61), "-61"); - TEST_MACRO(uint8_t, UINT8_C(200), "200"); - TEST_MACRO(int16_t, INT16_C(6161), "6161"); - TEST_MACRO(uint16_t, UINT16_C(32800), "32800"); - TEST_MACRO(int32_t, INT32_C(61616161), "61616161"); - TEST_MACRO(uint32_t, UINT32_C(4294967293), "4294967293"); - TEST_MACRO(int64_t, INT64_C(616161616161), "616161616161"); - TEST_MACRO(uint64_t, UINT64_C(9223372036854775807), "9223372036854775807"); - TEST_MACRO(uint32_t, UINT32_C(0xffff), "ffff", 16); - TEST_MACRO(float, 1.0f, "1.0"); - TEST_MACRO(double, 1.0, "1.0"); - TEST_MACRO(bool, true, "true"); - -#undef TEST_MACRO - - // Test failed TryParse -#define TEST_MACRO(type_t, string_value, ...) { \ - YYCC::yycc_u8string cache_string(YYCC_U8(string_value)); \ - type_t cache; \ - Assert(!YYCC::ParserHelper::TryParse(cache_string, cache, ##__VA_ARGS__), YYCC_U8("YYCC::StringHelper::TryParse<" #type_t ">")); \ -} - - TEST_MACRO(int8_t, "6161"); - TEST_MACRO(uint8_t, "32800"); - TEST_MACRO(int16_t, "61616161"); - TEST_MACRO(uint16_t, "4294967293"); - TEST_MACRO(int32_t, "616161616161"); - TEST_MACRO(uint32_t, "9223372036854775807"); - TEST_MACRO(int64_t, "616161616161616161616161"); - TEST_MACRO(uint64_t, "92233720368547758079223372036854775807"); - TEST_MACRO(float, "1e40"); - TEST_MACRO(double, "1e114514"); - TEST_MACRO(bool, "hello, world!"); - -#undef TEST_MACRO - - // Test ToString -#define TEST_MACRO(type_t, value, string_value, ...) { \ - type_t cache = value; \ - YYCC::yycc_u8string ret(YYCC::ParserHelper::ToString(cache, ##__VA_ARGS__)); \ - Assert(ret == YYCC_U8(string_value), YYCC_U8("YYCC::StringHelper::ToString<" #type_t ">")); \ -} - - TEST_MACRO(int8_t, INT8_C(-61), "-61"); - TEST_MACRO(uint8_t, UINT8_C(200), "200"); - TEST_MACRO(int16_t, INT16_C(6161), "6161"); - TEST_MACRO(uint16_t, UINT16_C(32800), "32800"); - TEST_MACRO(int32_t, INT32_C(61616161), "61616161"); - TEST_MACRO(uint32_t, UINT32_C(4294967293), "4294967293"); - TEST_MACRO(int64_t, INT64_C(616161616161), "616161616161"); - TEST_MACRO(uint64_t, UINT64_C(9223372036854775807), "9223372036854775807"); - TEST_MACRO(uint32_t, UINT32_C(0xffff), "ffff", 16); - TEST_MACRO(float, 1.0f, "1.0", std::chars_format::fixed, 1); - TEST_MACRO(double, 1.0, "1.0", std::chars_format::fixed, 1); - TEST_MACRO(bool, true, "true"); - -#undef TEST_MACRO - - } - static void DialogTestbench() { #if defined(YYCC_OS_WINDOWS) @@ -439,62 +319,6 @@ namespace YYCCTestbench { } - enum class TestFlagEnum : uint8_t { - Test1 = 0b00000000, - Test2 = 0b00000001, - Test3 = 0b00000010, - Test4 = 0b00000100, - Test5 = 0b00001000, - Test6 = 0b00010000, - Test7 = 0b00100000, - Test8 = 0b01000000, - Test9 = 0b10000000, - Inverted = 0b01111111, - Merged = Test3 + Test5, - }; - - static void EnumHelperTestbench() { - TestFlagEnum val; - - Assert(YYCC::EnumHelper::Merge(TestFlagEnum::Test3, TestFlagEnum::Test5) == TestFlagEnum::Merged, YYCC_U8("YYCC::EnumHelper::Merge")); - - Assert(YYCC::EnumHelper::Invert(TestFlagEnum::Test9) == TestFlagEnum::Inverted, YYCC_U8("YYCC::EnumHelper::Invert")); - - val = YYCC::EnumHelper::Merge(TestFlagEnum::Test3, TestFlagEnum::Test5); - YYCC::EnumHelper::Mask(val, TestFlagEnum::Test3); - Assert(YYCC::EnumHelper::Bool(val), YYCC_U8("YYCC::EnumHelper::Mask")); - val = YYCC::EnumHelper::Merge(TestFlagEnum::Test3, TestFlagEnum::Test5); - YYCC::EnumHelper::Mask(val, TestFlagEnum::Test4); - Assert(!YYCC::EnumHelper::Bool(val), YYCC_U8("YYCC::EnumHelper::Mask")); - - val = TestFlagEnum::Test3; - YYCC::EnumHelper::Add(val, TestFlagEnum::Test5); - Assert(val == TestFlagEnum::Merged, YYCC_U8("YYCC::EnumHelper::Add")); - - val = TestFlagEnum::Merged; - YYCC::EnumHelper::Remove(val, TestFlagEnum::Test5); - Assert(val == TestFlagEnum::Test3, YYCC_U8("YYCC::EnumHelper::Remove")); - - val = YYCC::EnumHelper::Merge(TestFlagEnum::Test3, TestFlagEnum::Test5); - Assert(YYCC::EnumHelper::Has(val, TestFlagEnum::Test3), YYCC_U8("YYCC::EnumHelper::Has")); - Assert(!YYCC::EnumHelper::Has(val, TestFlagEnum::Test4), YYCC_U8("YYCC::EnumHelper::Has")); - - Assert(!YYCC::EnumHelper::Bool(TestFlagEnum::Test1), YYCC_U8("YYCC::EnumHelper::Bool")); - Assert(YYCC::EnumHelper::Bool(TestFlagEnum::Test2), YYCC_U8("YYCC::EnumHelper::Bool")); - - } - - static void VersionMacroTestbench() { - Assert(YYCC_VERCMP_E(1, 2, 3, 1, 2, 3), YYCC_U8("YYCC_VERCMP_E")); - Assert(!YYCC_VERCMP_NE(1, 2, 3, 1, 2, 3), YYCC_U8("YYCC_VERCMP_NE")); - Assert(YYCC_VERCMP_G(1, 2, 3, 0, 2, 5), YYCC_U8("YYCC_VERCMP_G")); - Assert(YYCC_VERCMP_GE(1, 2, 3, 1, 2, 3), YYCC_U8("YYCC_VERCMP_GE")); - Assert(YYCC_VERCMP_NL(1, 2, 3, 1, 2, 3), YYCC_U8("YYCC_VERCMP_NL")); - Assert(YYCC_VERCMP_L(0, 2, 5, 1, 2, 3), YYCC_U8("YYCC_VERCMP_L")); - Assert(YYCC_VERCMP_LE(1, 2, 3, 1, 2, 3), YYCC_U8("YYCC_VERCMP_LE")); - Assert(YYCC_VERCMP_NG(1, 2, 3, 1, 2, 3), YYCC_U8("YYCC_VERCMP_NG")); - } - enum class TestEnum : int8_t { Test1, Test2, Test3 }; diff --git a/testbench/shared/literals.cpp b/testbench/shared/literals.cpp new file mode 100644 index 0000000..bd65919 --- /dev/null +++ b/testbench/shared/literals.cpp @@ -0,0 +1,203 @@ +#include "literals.hpp" +#include + +namespace yyccshared::literals { + +#define CONCAT(prefix, strl) prefix##strl +#define U8_LITERAL(strl) CONCAT(u8, strl) +#define U16_LITERAL(strl) CONCAT(u, strl) +#define U32_LITERAL(strl) CONCAT(U, strl) +#define WSTR_LITERAL(strl) CONCAT(L, strl) + +#pragma region UtfLiterals Data + + // UNICODE Test Strings + // Ref: https://stackoverflow.com/questions/478201/how-to-test-an-application-for-correct-encoding-e-g-utf-8 + +#define UNICODE_STR_JAPAN "\u30E6\u30FC\u30B6\u30FC\u5225\u30B5\u30A4\u30C8" +#define UNICODE_STR_CHINA "\u7B80\u4F53\u4E2D\u6587" +#define UNICODE_STR_KOREA "\uD06C\uB85C\uC2A4 \uD50C\uB7AB\uD3FC\uC73C\uB85C" +#define UNICODE_STR_ISRAEL "\u05DE\u05D3\u05D5\u05E8\u05D9\u05DD \u05DE\u05D1\u05D5\u05E7\u05E9\u05D9\u05DD" +#define UNICODE_STR_EGYPT "\u0623\u0641\u0636\u0644 \u0627\u0644\u0628\u062D\u0648\u062B" +#define UNICODE_STR_GREECE "\u03A3\u1F72 \u03B3\u03BD\u03C9\u03C1\u03AF\u03B6\u03C9 \u1F00\u03C0\u1F78" +#define UNICODE_STR_RUSSIA \ + "\u0414\u0435\u0441\u044F\u0442\u0443\u044E \u041C\u0435\u0436\u0434\u0443\u043D\u0430\u0440\u043E\u0434\u043D\u0443\u044E" +#define UNICODE_STR_THAILAND \ + "\u0E41\u0E1C\u0E48\u0E19\u0E14\u0E34\u0E19\u0E2E\u0E31\u0E48\u0E19\u0E40\u0E2A\u0E37\u0E48\u0E2D\u0E21\u0E42\u0E17\u0E23\u0E21\u0E41\u0E2A\u0E19\u0E2A\u0E31\u0E07\u0E40\u0E27\u0E0A" +#define UNICODE_STR_FRANCE "fran\u00E7ais langue \u00E9trang\u00E8re" +#define UNICODE_STR_SPAIN "ma\u00F1ana ol\u00E9" +#define UNICODE_STR_MATHMATICS "\u222E E\u22C5da = Q, n \u2192 \u221E, \u2211 f(i) = \u220F g(i)" +#define UNICODE_STR_EMOJI "\U0001F363 \u2716 \U0001F37A" // sushi x beer mug + + static std::vector UTFLIT_U8STR_VEC{ + U8_LITERAL(UNICODE_STR_JAPAN), + U8_LITERAL(UNICODE_STR_CHINA), + U8_LITERAL(UNICODE_STR_KOREA), + U8_LITERAL(UNICODE_STR_ISRAEL), + U8_LITERAL(UNICODE_STR_EGYPT), + U8_LITERAL(UNICODE_STR_GREECE), + U8_LITERAL(UNICODE_STR_RUSSIA), + U8_LITERAL(UNICODE_STR_THAILAND), + U8_LITERAL(UNICODE_STR_FRANCE), + U8_LITERAL(UNICODE_STR_SPAIN), + U8_LITERAL(UNICODE_STR_MATHMATICS), + U8_LITERAL(UNICODE_STR_EMOJI), + }; + static std::vector UTFLIT_WSTR_VEC{ + WSTR_LITERAL(UNICODE_STR_JAPAN), + WSTR_LITERAL(UNICODE_STR_CHINA), + WSTR_LITERAL(UNICODE_STR_KOREA), + WSTR_LITERAL(UNICODE_STR_ISRAEL), + WSTR_LITERAL(UNICODE_STR_EGYPT), + WSTR_LITERAL(UNICODE_STR_GREECE), + WSTR_LITERAL(UNICODE_STR_RUSSIA), + WSTR_LITERAL(UNICODE_STR_THAILAND), + WSTR_LITERAL(UNICODE_STR_FRANCE), + WSTR_LITERAL(UNICODE_STR_SPAIN), + WSTR_LITERAL(UNICODE_STR_MATHMATICS), + WSTR_LITERAL(UNICODE_STR_EMOJI), + }; + static std::vector UTFLIT_U16STR_VEC{ + U16_LITERAL(UNICODE_STR_JAPAN), + U16_LITERAL(UNICODE_STR_CHINA), + U16_LITERAL(UNICODE_STR_KOREA), + U16_LITERAL(UNICODE_STR_ISRAEL), + U16_LITERAL(UNICODE_STR_EGYPT), + U16_LITERAL(UNICODE_STR_GREECE), + U16_LITERAL(UNICODE_STR_RUSSIA), + U16_LITERAL(UNICODE_STR_THAILAND), + U16_LITERAL(UNICODE_STR_FRANCE), + U16_LITERAL(UNICODE_STR_SPAIN), + U16_LITERAL(UNICODE_STR_MATHMATICS), + U16_LITERAL(UNICODE_STR_EMOJI), + }; + static std::vector UTFLIT_U32STR_VEC{ + U32_LITERAL(UNICODE_STR_JAPAN), + U32_LITERAL(UNICODE_STR_CHINA), + U32_LITERAL(UNICODE_STR_KOREA), + U32_LITERAL(UNICODE_STR_ISRAEL), + U32_LITERAL(UNICODE_STR_EGYPT), + U32_LITERAL(UNICODE_STR_GREECE), + U32_LITERAL(UNICODE_STR_RUSSIA), + U32_LITERAL(UNICODE_STR_THAILAND), + U32_LITERAL(UNICODE_STR_FRANCE), + U32_LITERAL(UNICODE_STR_SPAIN), + U32_LITERAL(UNICODE_STR_MATHMATICS), + U32_LITERAL(UNICODE_STR_EMOJI), + }; + +#pragma endregion + +#pragma region UtfLiterals + + UtfLiterals::UtfLiterals() : + u8str_vec(UTFLIT_U8STR_VEC), u16str_vec(UTFLIT_U16STR_VEC), u32str_vec(UTFLIT_U32STR_VEC), wstr_vec(UTFLIT_WSTR_VEC) { + // Check whether each vector has same size. + bool okey = true; + size_t exp_size = this->u8str_vec.size(); + + if (this->u16str_vec.size() != exp_size) okey = false; + if (this->u32str_vec.size() != exp_size) okey = false; + if (this->wstr_vec.size() != exp_size) okey = false; + + if (!okey) throw std::logic_error("utf literal vector have different size"); + } + + UtfLiterals::~UtfLiterals() {} + + size_t UtfLiterals::get_size() const { + // We have checked the size of each vector in ctor. + // So we simply return the length of one of them. + return this->u8str_vec.size(); + } + + const std::vector &UtfLiterals::get_u8str_vec() const { + return this->u8str_vec; + } + + const std::vector &UtfLiterals::get_u16str_vec() const { + return this->u16str_vec; + } + + const std::vector &UtfLiterals::get_u32str_vec() const { + return this->u32str_vec; + } + + const std::vector &UtfLiterals::get_wstr_vec() const { + return this->wstr_vec; + } + +#pragma endregion + +#pragma region OtherLiteral + + OtherLiteral::OtherLiteral(std::string &&other_str, uint32_t windows_ident, std::string &&iconv_ident, std::u8string &&pycodec_ident) : + other_str(std::move(other_str)), windows_ident(windows_ident), iconv_ident(std::move(iconv_ident)), + pycodec_ident(std::move(pycodec_ident)) {} + + OtherLiteral::~OtherLiteral() {} + + const std::string &OtherLiteral::get_other_str() const { + return this->other_str; + } + + uint32_t OtherLiteral::get_windows_ident() const { + return this->windows_ident; + } + + const std::string &OtherLiteral::get_iconv_ident() const { + return this->iconv_ident; + } + + const std::u8string &OtherLiteral::get_pycodec_ident() const { + return this->pycodec_ident; + } + +#pragma endregion + +#pragma region OtherLiterals Data + + std::vector OTHERLIT_OTHERSTR_VEC{{"\xC4\xE3\xBA\xC3\xD6\xD0\xB9\xFA", UINT32_C(936), "GBK", u8"gbk"}}; + +#define OTHER_STR_GBK "\u4f60\u597d\u4e2d\u56fd" + + static std::vector OTHERLIT_U8STR_VEC{U8_LITERAL(OTHER_STR_GBK)}; + static std::vector OTHERLIT_WSTR_VEC{WSTR_LITERAL(OTHER_STR_GBK)}; + +#pragma endregion + +#pragma region OtherLiterals + + OtherLiterals::OtherLiterals() : other_str_vec(OTHERLIT_OTHERSTR_VEC), u8str_vec(OTHERLIT_U8STR_VEC), wstr_vec(OTHERLIT_WSTR_VEC) { + // Check whether each vector has same size. + bool okey = true; + size_t exp_size = this->other_str_vec.size(); + + if (this->u8str_vec.size() != exp_size) okey = false; + if (this->wstr_vec.size() != exp_size) okey = false; + + if (!okey) throw std::logic_error("utf literal vector have different size"); + } + + OtherLiterals::~OtherLiterals() {} + + size_t OtherLiterals::get_size() const { + // We have checked the size, return size directly. + return this->other_str_vec.size(); + } + + const std::vector &OtherLiterals::get_other_str_vec() const { + return this->other_str_vec; + } + + const std::vector &OtherLiterals::get_u8str_vec() const { + return this->u8str_vec; + } + + const std::vector &OtherLiterals::get_wstr_vec() const { + return this->wstr_vec; + } + +#pragma endregion + +} // namespace yyccshared::literals diff --git a/testbench/shared/literals.hpp b/testbench/shared/literals.hpp new file mode 100644 index 0000000..c478be1 --- /dev/null +++ b/testbench/shared/literals.hpp @@ -0,0 +1,64 @@ +#pragma once +#include +#include +#include +#include +#include + +namespace yyccshared::literals { + + class UtfLiterals { + public: + UtfLiterals(); + ~UtfLiterals(); + YYCC_DELETE_COPY_MOVE(UtfLiterals) + + size_t get_size() const; + const std::vector& get_u8str_vec() const; + const std::vector& get_u16str_vec() const; + const std::vector& get_u32str_vec() const; + const std::vector& get_wstr_vec() const; + + private: + const std::vector& u8str_vec; + const std::vector& u16str_vec; + const std::vector& u32str_vec; + const std::vector& wstr_vec; + }; + + class OtherLiteral { + public: + OtherLiteral(std::string&& other_str, uint32_t windows_ident, std::string&& iconv_ident, std::u8string&& pycodec_ident); + ~OtherLiteral(); + YYCC_DEFAULT_COPY_MOVE(OtherLiteral) + + const std::string& get_other_str() const; + uint32_t get_windows_ident() const; + const std::string& get_iconv_ident() const; + const std::u8string& get_pycodec_ident() const; + + private: + std::string other_str; + uint32_t windows_ident; + std::string iconv_ident; + std::u8string pycodec_ident; + }; + + class OtherLiterals { + public: + OtherLiterals(); + ~OtherLiterals(); + YYCC_DELETE_COPY_MOVE(OtherLiterals) + + size_t get_size() const; + const std::vector& get_other_str_vec() const; + const std::vector& get_u8str_vec() const; + const std::vector& get_wstr_vec() const; + + private: + const std::vector& other_str_vec; + const std::vector& u8str_vec; + const std::vector& wstr_vec; + }; + +} // namespace yyccshared::literals diff --git a/testbench/yycc/encoding/iconv.cpp b/testbench/yycc/encoding/iconv.cpp new file mode 100644 index 0000000..3708b3f --- /dev/null +++ b/testbench/yycc/encoding/iconv.cpp @@ -0,0 +1,116 @@ +#include +#include +#include +#include "../../shared/literals.hpp" + +#define ENC ::yycc::encoding::iconv + +namespace yycctest::encoding::iconv { +#if defined(YYCC_FEAT_ICONV) + + static auto UTF_LITERALS = ::yyccshared::literals::UtfLiterals(); + static auto OTHER_LITERALS = ::yyccshared::literals::OtherLiterals(); + + TEST(EncodingIconv, CharToUtf8) { + const auto& other_str_literals = OTHER_LITERALS.get_other_str_vec(); + const auto& u8str_literals = OTHER_LITERALS.get_u8str_vec(); + + for (size_t i = 0; i < OTHER_LITERALS.get_size(); ++i) { + const auto& other_str_literal = other_str_literals[i]; + ENC::CharToUtf8 cv(other_str_literal.get_iconv_ident()); + + auto rv = cv.to_utf8(other_str_literal.get_other_str()); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + + TEST(EncodingIconv, Utf8ToChar) { + const auto& other_str_literals = OTHER_LITERALS.get_other_str_vec(); + const auto& u8str_literals = OTHER_LITERALS.get_u8str_vec(); + + for (size_t i = 0; i < OTHER_LITERALS.get_size(); ++i) { + const auto& other_str_literal = other_str_literals[i]; + ENC::Utf8ToChar cv(other_str_literal.get_iconv_ident()); + + auto rv = cv.to_char(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), other_str_literal.get_other_str()); + } + } + + TEST(EncodingIconv, Utf8ToWchar) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& wstr_literals = UTF_LITERALS.get_wstr_vec(); + + ENC::Utf8ToWchar cv; + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = cv.to_wchar(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), wstr_literals[i]); + } + } + + TEST(EncodingIconv, WcharToUtf8) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& wstr_literals = UTF_LITERALS.get_wstr_vec(); + + ENC::WcharToUtf8 cv; + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = cv.to_utf8(wstr_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + + TEST(EncodingIconv, Utf8ToUtf16) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u16str_literals = UTF_LITERALS.get_u16str_vec(); + + ENC::Utf8ToUtf16 cv; + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = cv.to_utf16(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u16str_literals[i]); + } + } + + TEST(EncodingIconv, Utf16ToUtf8) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u16str_literals = UTF_LITERALS.get_u16str_vec(); + + ENC::Utf16ToUtf8 cv; + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = cv.to_utf8(u16str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + + TEST(EncodingIconv, Utf8ToUtf32) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u32str_literals = UTF_LITERALS.get_u32str_vec(); + + ENC::Utf8ToUtf32 cv; + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = cv.to_utf32(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u32str_literals[i]); + } + } + + TEST(EncodingIconv, Utf32ToUtf8) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u32str_literals = UTF_LITERALS.get_u32str_vec(); + + ENC::Utf32ToUtf8 cv; + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = cv.to_utf8(u32str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + + +#endif +} diff --git a/testbench/yycc/encoding/stl.cpp b/testbench/yycc/encoding/stl.cpp new file mode 100644 index 0000000..7467f8d --- /dev/null +++ b/testbench/yycc/encoding/stl.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include "../../shared/literals.hpp" + +#define ENC ::yycc::encoding::stl + +namespace yycctest::encoding::stl { + + static auto UTF_LITERALS = ::yyccshared::literals::UtfLiterals(); + + TEST(EncodingStl, Utf8ToUtf16) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u16str_literals = UTF_LITERALS.get_u16str_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf16(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u16str_literals[i]); + } + } + + TEST(EncodingStl, Utf16ToUtf8) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u16str_literals = UTF_LITERALS.get_u16str_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf8(u16str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + + TEST(EncodingStl, Utf8ToUtf32) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u32str_literals = UTF_LITERALS.get_u32str_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf32(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u32str_literals[i]); + } + } + + TEST(EncodingStl, Utf32ToUtf8) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u32str_literals = UTF_LITERALS.get_u32str_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf8(u32str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + +} diff --git a/testbench/yycc/encoding/utf_literal.hpp b/testbench/yycc/encoding/utf_literal.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/testbench/yycc/encoding/windows.cpp b/testbench/yycc/encoding/windows.cpp new file mode 100644 index 0000000..1dbae67 --- /dev/null +++ b/testbench/yycc/encoding/windows.cpp @@ -0,0 +1,137 @@ +#include +#include +#include +#include "../../shared/literals.hpp" + +#define ENC ::yycc::encoding::windows + +namespace yycctest::encoding::windows { +#if defined(YYCC_OS_WINDOWS) + + static auto UTF_LITERALS = ::yyccshared::literals::UtfLiterals(); + static auto OTHER_LITERALS = ::yyccshared::literals::OtherLiterals(); + + TEST(EncodingWindows, CharToWchar) { + const auto& other_str_literals = OTHER_LITERALS.get_other_str_vec(); + const auto& wstr_literals = OTHER_LITERALS.get_wstr_vec(); + + for (size_t i = 0; i < OTHER_LITERALS.get_size(); ++i) { + const auto& other_str_literal = other_str_literals[i]; + + auto rv = ENC::to_wchar(other_str_literal.get_other_str(), other_str_literal.get_windows_ident()); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), wstr_literals[i]); + } + } + + TEST(EncodingWindows, WcharToChar) { + const auto& other_str_literals = OTHER_LITERALS.get_other_str_vec(); + const auto& wstr_literals = OTHER_LITERALS.get_wstr_vec(); + + for (size_t i = 0; i < OTHER_LITERALS.get_size(); ++i) { + const auto& other_str_literal = other_str_literals[i]; + + auto rv = ENC::to_char(wstr_literals[i], other_str_literal.get_windows_ident()); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), other_str_literal.get_other_str()); + } + } + + TEST(EncodingWindows, CharToUtf8) { + const auto& other_str_literals = OTHER_LITERALS.get_other_str_vec(); + const auto& u8str_literals = OTHER_LITERALS.get_u8str_vec(); + + for (size_t i = 0; i < OTHER_LITERALS.get_size(); ++i) { + const auto& other_str_literal = other_str_literals[i]; + + auto rv = ENC::to_utf8(other_str_literal.get_other_str(), other_str_literal.get_windows_ident()); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + + TEST(EncodingWindows, Utf8ToChar) { + const auto& other_str_literals = OTHER_LITERALS.get_other_str_vec(); + const auto& u8str_literals = OTHER_LITERALS.get_u8str_vec(); + + for (size_t i = 0; i < OTHER_LITERALS.get_size(); ++i) { + const auto& other_str_literal = other_str_literals[i]; + + auto rv = ENC::to_char(u8str_literals[i], other_str_literal.get_windows_ident()); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), other_str_literal.get_other_str()); + } + } + + TEST(EncodingWindows, Utf8ToWchar) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& wstr_literals = UTF_LITERALS.get_wstr_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_wchar(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), wstr_literals[i]); + } + } + + TEST(EncodingWindows, WcharToUtf8) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& wstr_literals = UTF_LITERALS.get_wstr_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf8(wstr_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + +#if defined(YYCC_STL_MSSTL) + + TEST(EncodingWindows, Utf8ToUtf16) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u16str_literals = UTF_LITERALS.get_u16str_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf16(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u16str_literals[i]); + } + } + + TEST(EncodingWindows, Utf16ToUtf8) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u16str_literals = UTF_LITERALS.get_u16str_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf8(u16str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + + TEST(EncodingWindows, Utf8ToUtf32) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u32str_literals = UTF_LITERALS.get_u32str_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf32(u8str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u32str_literals[i]); + } + } + + TEST(EncodingWindows, Utf32ToUtf8) { + const auto& u8str_literals = UTF_LITERALS.get_u8str_vec(); + const auto& u32str_literals = UTF_LITERALS.get_u32str_vec(); + + for (size_t i = 0; i < UTF_LITERALS.get_size(); ++i) { + auto rv = ENC::to_utf8(u32str_literals[i]); + ASSERT_TRUE(rv.has_value()); + EXPECT_EQ(rv.value(), u8str_literals[i]); + } + } + +#endif + +#endif +} // namespace yycctest::encoding::windows