From f425b1379774e1294b9559a7499b9148a8593939 Mon Sep 17 00:00:00 2001 From: Jessica James Date: Mon, 6 Dec 2021 12:30:41 -0600 Subject: [PATCH] change object to use u8string instead of string --- src/common/app_parameters.cpp | 40 ++--- src/common/object.cpp | 2 +- src/common/parsers/json.cpp | 41 +++--- src/include/jessilib/app_parameters.hpp | 24 +-- src/include/jessilib/object.hpp | 26 +++- src/include/jessilib/parser.hpp | 6 +- src/test/app_parameters.cpp | 112 +++++++------- src/test/config.cpp | 20 +-- src/test/object.cpp | 186 ++++++++++++------------ src/test/parser.cpp | 21 +-- src/test/parsers/json.cpp | 66 ++++----- 11 files changed, 282 insertions(+), 262 deletions(-) diff --git a/src/common/app_parameters.cpp b/src/common/app_parameters.cpp index 4dfa9d8..e00532f 100644 --- a/src/common/app_parameters.cpp +++ b/src/common/app_parameters.cpp @@ -26,17 +26,19 @@ app_parameters::app_parameters(int in_argc, char** in_argv) } app_parameters::app_parameters(int in_argc, const char** in_argv) { + // TODO: discard argc/argv and use GetCommandLineW on Windows + // TODO: not assume argv is utf-8; it often will not be // Sanity safety check; should never happen if (in_argc <= 0 || in_argv == nullptr) { return; } // Populate path - m_path = in_argv[0]; + m_path = reinterpret_cast(in_argv[0]); // Process args - std::string_view key; - std::string value; + std::u8string_view key; + std::u8string value; auto flush_value = [&key, &value, this]() { // This is the start of a key; flush what we were previously processing if (!key.empty()) { @@ -51,7 +53,7 @@ app_parameters::app_parameters(int in_argc, const char** in_argv) { }; for (int index = 1; index < in_argc; ++index) { - const char* arg = in_argv[index]; + const char8_t* arg = reinterpret_cast(in_argv[index]); if (arg != nullptr && *arg != '\0') { // Check if this is a key or value if (*arg == '-') { @@ -66,7 +68,7 @@ app_parameters::app_parameters(int in_argc, const char** in_argv) { // Parse key for any value denominator ('=') size_t key_end = key.find('='); - if (key_end != std::string_view::npos) { + if (key_end != std::u8string_view::npos) { // arg contains start of a value value = key.substr(key_end + 1); key = key.substr(0, key_end); @@ -91,30 +93,32 @@ app_parameters::app_parameters(int in_argc, const char** in_argv) { flush_value(); // Populate m_switches_set from m_switches - m_switches_set = std::unordered_set{ m_switches.begin(), m_switches.end() }; + m_switches_set = std::unordered_set{ m_switches.begin(), m_switches.end() }; } -std::string_view app_parameters::path() const { +std::u8string_view app_parameters::path() const { return m_path; } -const std::vector& app_parameters::arguments() const { +const std::vector& app_parameters::arguments() const { return m_args; } -const std::vector& app_parameters::switches() const { +const std::vector& app_parameters::switches() const { return m_switches; } -const std::unordered_set& app_parameters::switches_set() const { +const std::unordered_set& app_parameters::switches_set() const { return m_switches_set; } -const std::unordered_map& app_parameters::values() const { +const std::unordered_map& app_parameters::values() const { return m_values; } object app_parameters::as_object() const { + using namespace std::literals; + // Null check if (m_path.empty() && m_args.empty()) { @@ -122,19 +126,19 @@ object app_parameters::as_object() const { return object{}; } - return std::map{ - { "Path", m_path }, - { "Args", m_args }, - { "Switches", m_switches }, - { "Values", m_values } + return std::map{ + { u8"Path"s, m_path }, + { u8"Args"s, m_args }, + { u8"Switches"s, m_switches }, + { u8"Values"s, m_values } }; } -bool app_parameters::has_switch(std::string_view in_switch) const { +bool app_parameters::has_switch(std::u8string_view in_switch) const { return m_switches_set.find(in_switch) != m_switches_set.end(); } -std::string_view app_parameters::get_value(std::string_view in_key, std::string_view in_default) const { +std::u8string_view app_parameters::get_value(std::u8string_view in_key, std::u8string_view in_default) const { auto result = m_values.find(in_key); // Safety check diff --git a/src/common/object.cpp b/src/common/object.cpp index e52df93..7df47b0 100644 --- a/src/common/object.cpp +++ b/src/common/object.cpp @@ -28,7 +28,7 @@ object::object(object&& in_object) { m_value = std::move(in_object.m_value); } -object::object(const char* in_str) +object::object(const text_char_type* in_str) : m_value{ string_type{ in_str } } { // Empty ctor body } diff --git a/src/common/parsers/json.cpp b/src/common/parsers/json.cpp index 429492e..175af1d 100644 --- a/src/common/parsers/json.cpp +++ b/src/common/parsers/json.cpp @@ -25,7 +25,7 @@ using namespace std::literals; namespace jessilib { -std::string make_json_string(std::string_view in_string) { +std::string make_json_string(std::u8string_view in_string) { std::string result; result.reserve(in_string.size() + 2); result = '\"'; @@ -44,8 +44,8 @@ std::string make_json_string(std::string_view in_string) { // overwrite last 2 zeroes with correct hexadecimal sequence char* data_end = result.data() + result.size(); - char* data = data_end - 2; - std::to_chars(data, data_end, in_string.front(), 16); + char* data = data_end - 2; // TODO: this isn't correct, is it? to_chars may only write 1 char in many cases + std::to_chars(data, data_end, static_cast(in_string.front()), 16); // TODO: use decode_codepoint } else if ((in_string.front() & 0x80) != 0) { // UTF-8 sequence; copy to bypass above processing if ((in_string.front() & 0x40) != 0) { @@ -62,7 +62,7 @@ std::string make_json_string(std::string_view in_string) { } // This is a 4-byte sequence - result += in_string.substr(0, 4); + result.append(reinterpret_cast(in_string.data()), 4); in_string.remove_prefix(4); continue; } @@ -73,7 +73,7 @@ std::string make_json_string(std::string_view in_string) { } // This is a 3-byte sequence - result += in_string.substr(0, 3); + result.append(reinterpret_cast(in_string.data()), 3); in_string.remove_prefix(3); continue; } @@ -84,7 +84,7 @@ std::string make_json_string(std::string_view in_string) { } // This is a 2-byte sequence - result += in_string.substr(0, 2); + result.append(reinterpret_cast(in_string.data()), 2); in_string.remove_prefix(2); continue; } @@ -94,7 +94,7 @@ std::string make_json_string(std::string_view in_string) { } else { // Character in standard ASCII table - result += in_string.front(); + result += static_cast(in_string.front()); } in_string.remove_prefix(1); @@ -132,8 +132,8 @@ uint16_t get_codepoint_from_hex(const std::string_view& in_data) { return value; } -std::string read_json_string(std::string_view& in_data) { - std::string result; +std::u8string read_json_string(std::string_view& in_data) { + std::u8string result; // Remove leading quotation in_data.remove_prefix(1); @@ -154,49 +154,49 @@ std::string read_json_string(std::string_view& in_data) { // Quote case '\"': in_data.remove_prefix(1); - result += '\"'; + result += u8'\"'; break; // Backslash case '\\': in_data.remove_prefix(1); - result += '\\'; + result += u8'\\'; break; // Forward slash case '/': in_data.remove_prefix(1); - result += '/'; + result += u8'/'; break; // Backspace case 'b': in_data.remove_prefix(1); - result += '\b'; + result += u8'\b'; break; // Formfeed case 'f': in_data.remove_prefix(1); - result += '\f'; + result += u8'\f'; break; // Newline case 'n': in_data.remove_prefix(1); - result += '\n'; + result += u8'\n'; break; // Carriage return case 'r': in_data.remove_prefix(1); - result += '\r'; + result += u8'\r'; break; // Horizontal tab case 't': in_data.remove_prefix(1); - result += '\t'; + result += u8'\t'; break; // Unicode codepoint @@ -258,8 +258,7 @@ std::string read_json_string(std::string_view& in_data) { } // Valid unicode sequence - result += in_data.substr(0, codepoint.units); - //result.append(reinterpret_cast(in_data.data()), codepoint.units); + result.append(reinterpret_cast(in_data.data()), codepoint.units); in_data.remove_prefix(codepoint.units); break; } @@ -492,8 +491,8 @@ std::string json_parser::serialize(const object& in_object) { case object::type::decimal: return std::to_string(in_object.get()); - case object::type::string: - return make_json_string(in_object.get()); + case object::type::text: + return make_json_string(in_object.get()); case object::type::array: { if (in_object.size() == 0) { diff --git a/src/include/jessilib/app_parameters.hpp b/src/include/jessilib/app_parameters.hpp index 912c12e..d1a98ca 100644 --- a/src/include/jessilib/app_parameters.hpp +++ b/src/include/jessilib/app_parameters.hpp @@ -25,24 +25,24 @@ public: app_parameters(int in_argc, char** in_argv); app_parameters(int in_argc, const char** in_argv); - std::string_view path() const; - const std::vector& arguments() const; - const std::vector& switches() const; - const std::unordered_set& switches_set() const; - const std::unordered_map& values() const; + std::u8string_view path() const; + const std::vector& arguments() const; + const std::vector& switches() const; + const std::unordered_set& switches_set() const; + const std::unordered_map& values() const; jessilib::object as_object() const; - bool has_switch(std::string_view in_switch) const; - std::string_view get_value(std::string_view in_key, std::string_view in_default = {}) const; + bool has_switch(std::u8string_view in_switch) const; + std::u8string_view get_value(std::u8string_view in_key, std::u8string_view in_default = {}) const; operator jessilib::object() const { return as_object(); } private: - std::string_view m_path; - std::vector m_args; - std::vector m_switches; - std::unordered_set m_switches_set; - std::unordered_map m_values; + std::u8string_view m_path; + std::vector m_args; + std::vector m_switches; + std::unordered_set m_switches_set; + std::unordered_map m_values; }; } // namespace jessilib diff --git a/src/include/jessilib/object.hpp b/src/include/jessilib/object.hpp index 32cce7c..46f2d35 100644 --- a/src/include/jessilib/object.hpp +++ b/src/include/jessilib/object.hpp @@ -31,8 +31,12 @@ namespace jessilib { class object { public: using array_type = std::vector; - using string_type = std::string; - using string_view_type = std::string_view; + using text_char_type = char8_t; + using text_type = std::basic_string; + using text_view_type = std::basic_string_view; + using data_type = std::vector; + using string_type = text_type; + using string_view_type = text_view_type; using map_type = std::map; using index_type = std::size_t; @@ -86,7 +90,8 @@ public: boolean, integer, decimal, - string, // TODO: consider separating into 'binary' (std::vector) and 'text' (string_type) types + text, + data, array, map }; @@ -152,7 +157,7 @@ public: } } - object(const char* in_str); + object(const text_char_type* in_str); object(const string_view_type& in_str); // Comparison operators @@ -454,6 +459,17 @@ public: return result; } + else if constexpr (std::is_same::value) { + // TODO: pull this into a separate method + uint64_t hash = 14695981039346656037ULL; + + for (auto byte : value) { + hash = hash ^ byte; + hash = hash * 1099511628211ULL; + } + + return hash; + } else { return std::hash{}(std::forward(value)); } @@ -464,7 +480,7 @@ private: using null_variant_t = void*; // TODO: consider replacing std::string with std::u8string (for strings) & std::vector (for data) // TODO: consider some more generic mechanism for underlying string type, to support utf-16 & utf-32 strings - std::variant m_value; + std::variant m_value; // TODO: note for future self, just use either first or last element in array_type to hold XML attributes // OR, have every XML tag objects be a map, with all subobjects being in a "__values" array subobject or such diff --git a/src/include/jessilib/parser.hpp b/src/include/jessilib/parser.hpp index 87dbd84..d568c53 100644 --- a/src/include/jessilib/parser.hpp +++ b/src/include/jessilib/parser.hpp @@ -38,9 +38,9 @@ public: * @return A valid (possibly null) object */ virtual object deserialize(std::istream& in_stream); - virtual object deserialize(std::string_view in_data) = 0; + virtual object deserialize(std::string_view in_data) = 0; // TODO: serialize from arbitrary unicode strings virtual void serialize(std::ostream& in_stream, const object& in_object); - virtual std::string serialize(const object& in_object) = 0; + virtual std::string serialize(const object& in_object) = 0; // TODO: serialize to arbitrary unicode strings }; // parser template @@ -57,4 +57,4 @@ public: impl::parser_manager::id m_id; }; // parser_registration -} // namespace jessilib \ No newline at end of file +} // namespace jessilib diff --git a/src/test/app_parameters.cpp b/src/test/app_parameters.cpp index 445ded6..d877ee7 100644 --- a/src/test/app_parameters.cpp +++ b/src/test/app_parameters.cpp @@ -75,7 +75,7 @@ TEST(AppParametersTest, path_only) { ArgWrapper args{ "/path/to/exe" }; app_parameters parameters{ args.argc(), args.argv() }; - EXPECT_EQ(parameters.path(), "/path/to/exe"); + EXPECT_EQ(parameters.path(), u8"/path/to/exe"); EXPECT_TRUE(parameters.arguments().empty()); EXPECT_TRUE(parameters.switches().empty()); EXPECT_TRUE(parameters.switches_set().empty()); @@ -83,7 +83,7 @@ TEST(AppParametersTest, path_only) { auto obj = parameters.as_object(); EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); } TEST(AppParametersTest, single_switch) { @@ -98,9 +98,9 @@ TEST(AppParametersTest, single_switch) { auto obj = parameters.as_object(); EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], object{ std::vector{ "-switch" } }); - EXPECT_EQ(obj["Switches"], object{ std::vector{ "switch" } }); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], object{ std::vector{ u8"-switch" } }); + EXPECT_EQ(obj[u8"Switches"], object{ std::vector{ u8"switch" } }); } TEST(AppParametersTest, double_switch) { @@ -114,12 +114,12 @@ TEST(AppParametersTest, double_switch) { EXPECT_TRUE(parameters.values().empty()); auto obj = parameters.as_object(); - std::vector expected_args{ "-switch1", "--switch2" }; - std::vector expected_switches{ "switch1", "switch2" }; + std::vector expected_args{ u8"-switch1", u8"--switch2" }; + std::vector expected_switches{ u8"switch1", u8"switch2" }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Switches"], expected_switches); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Switches"], expected_switches); } TEST(AppParametersTest, duplicate_switch) { @@ -133,12 +133,12 @@ TEST(AppParametersTest, duplicate_switch) { EXPECT_TRUE(parameters.values().empty()); auto obj = parameters.as_object(); - std::vector expected_args{ "-switch", "--switch" }; - std::vector expected_switches{ "switch", "switch" }; + std::vector expected_args{ u8"-switch", u8"--switch" }; + std::vector expected_switches{ u8"switch", u8"switch" }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Switches"], expected_switches); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Switches"], expected_switches); } TEST(AppParametersTest, single_value) { @@ -152,12 +152,12 @@ TEST(AppParametersTest, single_value) { EXPECT_EQ(parameters.values().size(), 1U); auto obj = parameters.as_object(); - std::vector expected_args{ "-key", "value" }; - std::map expected_values{ { "key", "value" } }; + std::vector expected_args{ u8"-key", u8"value" }; + std::map expected_values{ { u8"key", u8"value" } }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Values"], expected_values); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Values"], expected_values); } TEST(AppParametersTest, single_value_eq) { @@ -171,12 +171,12 @@ TEST(AppParametersTest, single_value_eq) { EXPECT_EQ(parameters.values().size(), 1U); auto obj = parameters.as_object(); - std::vector expected_args{ "-key=value" }; - std::map expected_values{ { "key", "value" } }; + std::vector expected_args{ u8"-key=value" }; + std::map expected_values{ { u8"key", u8"value" } }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Values"], expected_values); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Values"], expected_values); } TEST(AppParametersTest, multiword_value) { @@ -190,12 +190,12 @@ TEST(AppParametersTest, multiword_value) { EXPECT_EQ(parameters.values().size(), 1U); auto obj = parameters.as_object(); - std::vector expected_args{ "-key", "valuePart1", "valuePart2" }; - std::map expected_values{ { "key", "valuePart1 valuePart2" } }; + std::vector expected_args{ u8"-key", u8"valuePart1", u8"valuePart2" }; + std::map expected_values{ { u8"key", u8"valuePart1 valuePart2" } }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Values"], expected_values); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Values"], expected_values); } TEST(AppParametersTest, multiword_value_eq) { @@ -209,12 +209,12 @@ TEST(AppParametersTest, multiword_value_eq) { EXPECT_EQ(parameters.values().size(), 1U); auto obj = parameters.as_object(); - std::vector expected_args{ "-key=valuePart1", "valuePart2" }; - std::map expected_values{ { "key", "valuePart1 valuePart2" } }; + std::vector expected_args{ u8"-key=valuePart1", u8"valuePart2" }; + std::map expected_values{ { u8"key", u8"valuePart1 valuePart2" } }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Values"], expected_values); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Values"], expected_values); } TEST(AppParametersTest, double_value) { @@ -228,12 +228,12 @@ TEST(AppParametersTest, double_value) { EXPECT_EQ(parameters.values().size(), 2U); auto obj = parameters.as_object(); - std::vector expected_args{ "-key", "value", "--key2", "value2" }; - std::map expected_values{ { "key", "value" }, { "key2", "value2" } }; + std::vector expected_args{ u8"-key", u8"value", u8"--key2", u8"value2" }; + std::map expected_values{ { u8"key", u8"value" }, { u8"key2", u8"value2" } }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Values"], expected_values); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Values"], expected_values); } TEST(AppParametersTest, double_value_eq) { @@ -247,12 +247,12 @@ TEST(AppParametersTest, double_value_eq) { EXPECT_EQ(parameters.values().size(), 2U); auto obj = parameters.as_object(); - std::vector expected_args{ "-key=value", "--key2=value2" }; - std::map expected_values{ { "key", "value" }, { "key2", "value2" } }; + std::vector expected_args{ u8"-key=value", u8"--key2=value2" }; + std::map expected_values{ { u8"key", u8"value" }, { u8"key2", u8"value2" } }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Values"], expected_values); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Values"], expected_values); } TEST(AppParametersTest, switch_and_value) { @@ -266,16 +266,16 @@ TEST(AppParametersTest, switch_and_value) { EXPECT_EQ(parameters.values().size(), 1U); auto obj = parameters.as_object(); - std::vector expected_args{ "--switch", "-key", "value" }; - std::vector expected_switches{ "switch" }; - std::map expected_values{ { "key", "value" } }; + std::vector expected_args{ u8"--switch", u8"-key", u8"value" }; + std::vector expected_switches{ u8"switch" }; + std::map expected_values{ { u8"key", u8"value" } }; EXPECT_FALSE(obj.null()); - EXPECT_EQ(obj["Path"], "/path/to/exe"); - EXPECT_EQ(obj["Args"], expected_args); - EXPECT_EQ(obj["Switches"], expected_switches); - EXPECT_EQ(obj["Values"], expected_values); - - EXPECT_TRUE(parameters.has_switch("switch")); - EXPECT_FALSE(parameters.has_switch("switch2")); - EXPECT_EQ(parameters.get_value("key"), "value"); + EXPECT_EQ(obj[u8"Path"], u8"/path/to/exe"); + EXPECT_EQ(obj[u8"Args"], expected_args); + EXPECT_EQ(obj[u8"Switches"], expected_switches); + EXPECT_EQ(obj[u8"Values"], expected_values); + + EXPECT_TRUE(parameters.has_switch(u8"switch")); + EXPECT_FALSE(parameters.has_switch(u8"switch2")); + EXPECT_EQ(parameters.get_value(u8"key"), u8"value"); } diff --git a/src/test/config.cpp b/src/test/config.cpp index 3b8402b..4d6117b 100644 --- a/src/test/config.cpp +++ b/src/test/config.cpp @@ -55,14 +55,14 @@ TEST(ConfigTest, get_format) { TEST(ConfigTest, read_object) { std::filesystem::path file_path = make_tmp_file("read_object.test", "some_data"); - EXPECT_EQ(config::read_object(file_path).get(), "some_data"); + EXPECT_EQ(config::read_object(file_path).get(), u8"some_data"); } TEST(ConfigTest, write_object) { std::filesystem::path file_path = make_tmp_file("write_object.test", "some_data"); config::write_object(object{}, file_path); - EXPECT_EQ(config::read_object(file_path).get(), "serialize_result"); + EXPECT_EQ(config::read_object(file_path).get(), u8"serialize_result"); } TEST(ConfigTest, load) { @@ -75,7 +75,7 @@ TEST(ConfigTest, load) { l_config.load(file_path); // Verify - EXPECT_EQ(l_config.data().get(), "some_data"); + EXPECT_EQ(l_config.data().get(), u8"some_data"); EXPECT_EQ(l_config.filename(), file_path); EXPECT_EQ(l_config.format(), "test"); } @@ -94,25 +94,25 @@ TEST(ConfigTest, reload) { // Reload data from disk and compare l_config.reload(); - EXPECT_EQ(l_config.data().get(), "some_other_data"); + EXPECT_EQ(l_config.data().get(), u8"some_other_data"); } TEST(ConfigTest, set_data) { config l_config; - l_config.set_data("some_data"); - EXPECT_EQ(l_config.data().get(), "some_data"); + l_config.set_data(u8"some_data"); + EXPECT_EQ(l_config.data().get(), u8"some_data"); } TEST(ConfigTest, write) { config l_config; std::filesystem::path file_path = make_tmp_file("write.test", ""); - l_config.set_data("some_data"); + l_config.set_data(u8"some_data"); l_config.write(file_path); l_config.reload(); - EXPECT_EQ(l_config.data().get(), "some_data"); + EXPECT_EQ(l_config.data().get(), u8"some_data"); } TEST(ConfigTest, rewrite) { @@ -125,12 +125,12 @@ TEST(ConfigTest, rewrite) { l_config.load(file_path); // Set some other data - l_config.set_data("some_other_data"); + l_config.set_data(u8"some_other_data"); // Write data to disk l_config.write(); // Reload from disk and verify l_config.reload(); - EXPECT_EQ(l_config.data().get(), "some_other_data"); + EXPECT_EQ(l_config.data().get(), u8"some_other_data"); } diff --git a/src/test/object.cpp b/src/test/object.cpp index d266782..d3de616 100644 --- a/src/test/object.cpp +++ b/src/test/object.cpp @@ -27,19 +27,19 @@ using unsigned_char_t = unsigned char; using long_long_t = long long; using long_double_t = long double; -using map_str_str = std::map; -using map_str_strv = std::map; -using map_str_obj = std::map; -using map_strv_str = std::map; -using map_strv_strv = std::map; -using map_strv_obj = std::map; - -using unordered_map_str_str = std::unordered_map; -using unordered_map_str_strv = std::unordered_map; -using unordered_map_str_obj = std::unordered_map; -using unordered_map_strv_str = std::unordered_map; -using unordered_map_strv_strv = std::unordered_map; -using unordered_map_strv_obj = std::unordered_map; +using map_str_str = std::map; +using map_str_strv = std::map; +using map_str_obj = std::map; +using map_strv_str = std::map; +using map_strv_strv = std::map; +using map_strv_obj = std::map; + +using unordered_map_str_str = std::unordered_map; +using unordered_map_str_strv = std::unordered_map; +using unordered_map_str_obj = std::unordered_map; +using unordered_map_strv_str = std::unordered_map; +using unordered_map_strv_strv = std::unordered_map; +using unordered_map_strv_obj = std::unordered_map; /** basic tests; these test function calls against null objects and heavily test for compilation errors */ @@ -66,7 +66,7 @@ TEST(ObjectTest, basic_has) { EXPECT_FALSE(obj.has()); EXPECT_FALSE(obj.has()); EXPECT_FALSE(obj.has()); - EXPECT_FALSE(obj.has()); + EXPECT_FALSE(obj.has()); EXPECT_FALSE(obj.has()); EXPECT_FALSE(obj.has()); } @@ -85,7 +85,7 @@ TEST(ObjectTest, basic_has_vector) { EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); - EXPECT_FALSE(obj.has>()); + EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); } @@ -103,7 +103,7 @@ TEST(ObjectTest, basic_has_list) { EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); - EXPECT_FALSE(obj.has>()); + EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); } @@ -121,7 +121,7 @@ TEST(ObjectTest, basic_has_forward_list) { EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); - EXPECT_FALSE(obj.has>()); + EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); } @@ -139,7 +139,7 @@ TEST(ObjectTest, basic_has_set) { EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); - EXPECT_FALSE(obj.has>()); + EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); } @@ -157,7 +157,7 @@ TEST(ObjectTest, basic_has_unordered_set) { EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); - EXPECT_FALSE(obj.has>()); + EXPECT_FALSE(obj.has>()); EXPECT_FALSE(obj.has>()); } @@ -199,7 +199,7 @@ TEST(ObjectTest, basic_get) { EXPECT_EQ(obj.get(), float{}); EXPECT_EQ(obj.get(), double{}); EXPECT_EQ(obj.get(), long_double_t{}); - EXPECT_EQ(obj.get(), std::string{}); + EXPECT_EQ(obj.get(), std::u8string{}); EXPECT_TRUE(obj.get().empty()); EXPECT_TRUE(obj.get().empty()); } @@ -218,7 +218,7 @@ TEST(ObjectTest, basic_get_vector) { EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); - EXPECT_TRUE(obj.get>().empty()); + EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); } @@ -236,7 +236,7 @@ TEST(ObjectTest, basic_get_list) { EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); - EXPECT_TRUE(obj.get>().empty()); + EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); } @@ -254,7 +254,7 @@ TEST(ObjectTest, basic_get_forward_list) { EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); - EXPECT_TRUE(obj.get>().empty()); + EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); } @@ -272,7 +272,7 @@ TEST(ObjectTest, basic_get_set) { EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); - EXPECT_TRUE(obj.get>().empty()); + EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); } @@ -290,7 +290,7 @@ TEST(ObjectTest, basic_get_multiset) { EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); - EXPECT_TRUE(obj.get>().empty()); + EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); } @@ -308,7 +308,7 @@ TEST(ObjectTest, basic_get_unordered_set) { EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); - EXPECT_TRUE(obj.get>().empty()); + EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); } @@ -326,7 +326,7 @@ TEST(ObjectTest, basic_get_unordered_multiset) { EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); - EXPECT_TRUE(obj.get>().empty()); + EXPECT_TRUE(obj.get>().empty()); EXPECT_TRUE(obj.get>().empty()); } @@ -351,21 +351,21 @@ TEST(ObjectTest, basic_value_constructor) { OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(float); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(double); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(long_double_t); - OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::string); + OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::u8string); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(object::array_type); // const char* { - object obj{ "" }; - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), std::string{}); + object obj{ u8"" }; + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), std::u8string{}); } - // std::string_view + // std::u8string_view { - object obj{ ""sv }; - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), std::string{}); + object obj{ u8""sv }; + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), std::u8string{}); } } @@ -381,7 +381,7 @@ TEST(ObjectTest, basic_value_constructor_vector) { OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::vector); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::vector); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::vector); - OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::vector); + OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::vector); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::vector); } @@ -397,7 +397,7 @@ TEST(ObjectTest, basic_value_constructor_list) { OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::list); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::list); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::list); - OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::list); + OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::list); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::list); } @@ -413,7 +413,7 @@ TEST(ObjectTest, basic_value_constructor_forward_list) { OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::forward_list); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::forward_list); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::forward_list); - OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::forward_list); + OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::forward_list); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::forward_list); } @@ -429,7 +429,7 @@ TEST(ObjectTest, basic_value_constructor_set) { OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::set); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::set); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::set); - OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::set); + OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::set); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::set); } @@ -445,7 +445,7 @@ TEST(ObjectTest, basic_value_constructor_multiset) { OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::multiset); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::multiset); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::multiset); - OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::multiset); + OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::multiset); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::multiset); } @@ -461,7 +461,7 @@ TEST(ObjectTest, basic_value_constructor_unordered_set) { OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_set); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_set); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_set); - OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_set); + OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_set); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_set); } @@ -477,7 +477,7 @@ TEST(ObjectTest, basic_value_constructor_unordered_multiset) { OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_multiset); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_multiset); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_multiset); - OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_multiset); + OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_multiset); OBJECT_BASIC_VALUE_CONSTRUCTOR_TEST(std::unordered_set); } @@ -502,18 +502,18 @@ TEST(ObjectTest, basic_set) { OBJECT_BASIC_SET_TEST(obj, float); OBJECT_BASIC_SET_TEST(obj, double); OBJECT_BASIC_SET_TEST(obj, long_double_t); - OBJECT_BASIC_SET_TEST(obj, std::string); + OBJECT_BASIC_SET_TEST(obj, std::u8string); OBJECT_BASIC_SET_TEST(obj, object::array_type); // const char* - obj.set(""); - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), std::string{}); + obj.set(u8""); + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), std::u8string{}); - // std::string_view - obj.set(""sv); - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), std::string{}); + // std::u8string_view + obj.set(u8""sv); + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), std::u8string{}); } TEST(ObjectTest, basic_set_vector) { @@ -530,7 +530,7 @@ TEST(ObjectTest, basic_set_vector) { OBJECT_BASIC_SET_TEST(obj, std::vector); OBJECT_BASIC_SET_TEST(obj, std::vector); OBJECT_BASIC_SET_TEST(obj, std::vector); - OBJECT_BASIC_SET_TEST(obj, std::vector); + OBJECT_BASIC_SET_TEST(obj, std::vector); OBJECT_BASIC_SET_TEST(obj, std::vector); } @@ -548,7 +548,7 @@ TEST(ObjectTest, basic_set_list) { OBJECT_BASIC_SET_TEST(obj, std::list); OBJECT_BASIC_SET_TEST(obj, std::list); OBJECT_BASIC_SET_TEST(obj, std::list); - OBJECT_BASIC_SET_TEST(obj, std::list); + OBJECT_BASIC_SET_TEST(obj, std::list); OBJECT_BASIC_SET_TEST(obj, std::list); } @@ -566,7 +566,7 @@ TEST(ObjectTest, basic_set_forward_list) { OBJECT_BASIC_SET_TEST(obj, std::forward_list); OBJECT_BASIC_SET_TEST(obj, std::forward_list); OBJECT_BASIC_SET_TEST(obj, std::forward_list); - OBJECT_BASIC_SET_TEST(obj, std::forward_list); + OBJECT_BASIC_SET_TEST(obj, std::forward_list); OBJECT_BASIC_SET_TEST(obj, std::forward_list); } @@ -584,7 +584,7 @@ TEST(ObjectTest, basic_set_set) { OBJECT_BASIC_SET_TEST(obj, std::set); OBJECT_BASIC_SET_TEST(obj, std::set); OBJECT_BASIC_SET_TEST(obj, std::set); - OBJECT_BASIC_SET_TEST(obj, std::set); + OBJECT_BASIC_SET_TEST(obj, std::set); OBJECT_BASIC_SET_TEST(obj, std::set); } @@ -602,7 +602,7 @@ TEST(ObjectTest, basic_set_multiset) { OBJECT_BASIC_SET_TEST(obj, std::multiset); OBJECT_BASIC_SET_TEST(obj, std::multiset); OBJECT_BASIC_SET_TEST(obj, std::multiset); - OBJECT_BASIC_SET_TEST(obj, std::multiset); + OBJECT_BASIC_SET_TEST(obj, std::multiset); OBJECT_BASIC_SET_TEST(obj, std::multiset); } @@ -620,7 +620,7 @@ TEST(ObjectTest, basic_set_unordered_set) { OBJECT_BASIC_SET_TEST(obj, std::unordered_set); OBJECT_BASIC_SET_TEST(obj, std::unordered_set); OBJECT_BASIC_SET_TEST(obj, std::unordered_set); - OBJECT_BASIC_SET_TEST(obj, std::unordered_set); + OBJECT_BASIC_SET_TEST(obj, std::unordered_set); OBJECT_BASIC_SET_TEST(obj, std::unordered_set); } @@ -638,7 +638,7 @@ TEST(ObjectTest, basic_set_unordered_multiset) { OBJECT_BASIC_SET_TEST(obj, std::unordered_multiset); OBJECT_BASIC_SET_TEST(obj, std::unordered_multiset); OBJECT_BASIC_SET_TEST(obj, std::unordered_multiset); - OBJECT_BASIC_SET_TEST(obj, std::unordered_multiset); + OBJECT_BASIC_SET_TEST(obj, std::unordered_multiset); OBJECT_BASIC_SET_TEST(obj, std::unordered_set); } @@ -663,18 +663,18 @@ TEST(ObjectTest, basic_assignment_operator) { OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, float); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, double); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, long_double_t); - OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::string); + OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::u8string); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, object::array_type); // const char* - obj = ""; - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), std::string{}); + obj = u8""; + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), std::u8string{}); - // std::string_view - obj = ""sv; - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), std::string{}); + // std::u8string_view + obj = u8""sv; + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), std::u8string{}); } TEST(ObjectTest, basic_assignment_operator_vector) { @@ -691,7 +691,7 @@ TEST(ObjectTest, basic_assignment_operator_vector) { OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::vector); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::vector); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::vector); - OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::vector); + OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::vector); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::vector); } @@ -709,7 +709,7 @@ TEST(ObjectTest, basic_assignment_operator_list) { OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::list); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::list); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::list); - OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::list); + OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::list); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::list); } @@ -727,7 +727,7 @@ TEST(ObjectTest, basic_assignment_operator_forward_list) { OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::forward_list); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::forward_list); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::forward_list); - OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::forward_list); + OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::forward_list); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::forward_list); } @@ -745,7 +745,7 @@ TEST(ObjectTest, basic_assignment_operator_set) { OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::set); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::set); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::set); - OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::set); + OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::set); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::set); } @@ -763,7 +763,7 @@ TEST(ObjectTest, basic_assignment_operator_multiset) { OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::multiset); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::multiset); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::multiset); - OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::multiset); + OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::multiset); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::multiset); } @@ -781,7 +781,7 @@ TEST(ObjectTest, basic_assignment_operator_unordered_set) { OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_set); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_set); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_set); - OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_set); + OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_set); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_set); } @@ -799,7 +799,7 @@ TEST(ObjectTest, basic_assignment_operator_unordered_multiset) { OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_multiset); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_multiset); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_multiset); - OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_multiset); + OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_multiset); OBJECT_BASIC_ASSIGNMENT_OPERATOR_TEST(obj, std::unordered_set); } @@ -808,17 +808,17 @@ TEST(ObjectTest, basic_assignment_operator_unordered_multiset) { TEST(ObjectTest, basic_map_access_operator) { object obj; - obj["test"] = 1234; - EXPECT_EQ(obj["test"].get(), 1234); - EXPECT_EQ(obj["test2"].get(), 0); + obj[u8"test"] = 1234; + EXPECT_EQ(obj[u8"test"].get(), 1234); + EXPECT_EQ(obj[u8"test2"].get(), 0); - obj["test"] = 4567; - EXPECT_EQ(obj["test"].get(), 4567); - EXPECT_EQ(obj["test2"].get(), 0); + obj[u8"test"] = 4567; + EXPECT_EQ(obj[u8"test"].get(), 4567); + EXPECT_EQ(obj[u8"test2"].get(), 0); - obj["test2"] = 1234; - EXPECT_EQ(obj["test"].get(), 4567); - EXPECT_EQ(obj["test2"].get(), 1234); + obj[u8"test2"] = 1234; + EXPECT_EQ(obj[u8"test"].get(), 4567); + EXPECT_EQ(obj[u8"test2"].get(), 1234); } TEST(ObjectTest, basic_array_access_operator) { @@ -914,31 +914,31 @@ TEST(ObjectTest, set_float) { TEST(ObjectTest, set_string) { object obj; - obj.set("Jessica"); + obj.set(u8"Jessica"); - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), "Jessica"); + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), u8"Jessica"); EXPECT_FALSE(obj.has()); EXPECT_FALSE(obj.get()); - obj.set("was"s); + obj.set(u8"was"s); - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), "was"); + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), u8"was"); EXPECT_FALSE(obj.has()); EXPECT_FALSE(obj.get()); - obj.set("here"sv); + obj.set(u8"here"sv); - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), "here"); + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), u8"here"); EXPECT_FALSE(obj.has()); EXPECT_FALSE(obj.get()); - obj.set(""); + obj.set(u8""); - EXPECT_TRUE(obj.has()); - EXPECT_EQ(obj.get(), ""); + EXPECT_TRUE(obj.has()); + EXPECT_EQ(obj.get(), u8""); EXPECT_FALSE(obj.has()); EXPECT_FALSE(obj.get()); } diff --git a/src/test/parser.cpp b/src/test/parser.cpp index 2dfd8e2..0171d3b 100644 --- a/src/test/parser.cpp +++ b/src/test/parser.cpp @@ -20,6 +20,7 @@ #include "test.hpp" #include "jessilib/parser.hpp" #include "jessilib/serialize.hpp" +#include "jessilib/unicode.hpp" using namespace jessilib; using namespace std::literals; @@ -45,15 +46,15 @@ public: /** default serialize/deserialize implementations */ static std::string serialize_default(const object& in_object) { - if (in_object.has()) { - return in_object.get(); + if (in_object.has()) { + return string_cast(in_object.get()); } return static_cast(DEFAULT_SERIALIZE_RESULT); } static object deserialize_default(std::string_view in_data) { - return object{ in_data }; + return object{ string_view_cast(in_data) }; } /** static members */ @@ -82,31 +83,31 @@ class ParserTest : public base_test { /** Parser tests */ TEST_F(ParserTest, find_parser) { - EXPECT_NO_THROW(serialize_object("test_data", "test")); + EXPECT_NO_THROW(serialize_object(u8"test_data", "test")); EXPECT_NO_THROW(deserialize_object("test_data"sv, "test")); - EXPECT_THROW(serialize_object("test_data", "invalid_format_test"), format_not_available); + EXPECT_THROW(serialize_object(u8"test_data", "invalid_format_test"), format_not_available); EXPECT_THROW(deserialize_object("test_data"sv, "invalid_format_test"), format_not_available); } TEST_F(ParserTest, temp_parser) { - EXPECT_THROW(serialize_object("test_data", "test_tmp"), format_not_available); + EXPECT_THROW(serialize_object(u8"test_data", "test_tmp"), format_not_available); EXPECT_THROW(deserialize_object("test_data"sv, "test_tmp"), format_not_available); { parser_registration test_tmp_registration{ "test_tmp" }; - EXPECT_NO_THROW(serialize_object("test_data", "test_tmp")); + EXPECT_NO_THROW(serialize_object(u8"test_data", "test_tmp")); EXPECT_NO_THROW(deserialize_object("test_data"sv, "test_tmp")); } - EXPECT_THROW(serialize_object("test_data", "test_tmp"), format_not_available); + EXPECT_THROW(serialize_object(u8"test_data", "test_tmp"), format_not_available); EXPECT_THROW(deserialize_object("test_data"sv, "test_tmp"), format_not_available); } TEST_F(ParserTest, serialize) { - EXPECT_EQ(serialize_object("test_data", "test"), "test_data"); + EXPECT_EQ(serialize_object(u8"test_data", "test"), "test_data"); } TEST_F(ParserTest, deserialize) { - EXPECT_EQ(deserialize_object("test_data"sv, "test").get(), "test_data"); + EXPECT_EQ(deserialize_object("test_data"sv, "test").get(), u8"test_data"); } diff --git a/src/test/parsers/json.cpp b/src/test/parsers/json.cpp index 688080f..50f5e04 100644 --- a/src/test/parsers/json.cpp +++ b/src/test/parsers/json.cpp @@ -56,9 +56,9 @@ void expect_eq(LeftT in_left, RightT in_right) { TEST(JsonParser, serialize_string) { json_parser parser; - EXPECT_EQ(parser.serialize("text"), R"json("text")json"); - expect_eq(parser.serialize("\"text\""), R"json("\"text\"")json"); - expect_eq(parser.serialize("\"te\x10xt\""), R"json("\"te\u0010xt\"")json"); + EXPECT_EQ(parser.serialize(u8"text"), R"json("text")json"); + expect_eq(parser.serialize(u8"\"text\""), R"json("\"text\"")json"); + expect_eq(parser.serialize(u8"\"te\x10xt\""), R"json("\"te\u0010xt\"")json"); } TEST(JsonParser, serialize_array) { @@ -66,7 +66,7 @@ TEST(JsonParser, serialize_array) { std::vector array { true, 1234, - "text", + u8"text", object{} }; @@ -78,10 +78,10 @@ TEST(JsonParser, serialize_map) { json_parser parser; object obj; - obj["some_bool"] = true; - obj["some_int"] = 1234; - obj["some_string"] = "text"; - obj["some_null"]; + obj[u8"some_bool"] = true; + obj[u8"some_int"] = 1234; + obj[u8"some_string"] = u8"text"; + obj[u8"some_null"]; EXPECT_EQ(parser.serialize(obj), R"json({"some_bool":true,"some_int":1234,"some_null":null,"some_string":"text"})json"); @@ -120,7 +120,7 @@ TEST(JsonParser, deserialize_decimal) { TEST(JsonParser, deserialize_string) { json_parser parser; - EXPECT_EQ(parser.deserialize(R"json("text")json"sv), "text"); + EXPECT_EQ(parser.deserialize(R"json("text")json"sv), u8"text"); } TEST(JsonParser, deserialize_array) { @@ -142,7 +142,7 @@ TEST(JsonParser, deserialize_array) { EXPECT_EQ(array[2], 1234); EXPECT_DOUBLE_EQ(array[3].get(), 12.34); EXPECT_DOUBLE_EQ(array[4].get(), 0.1234); - EXPECT_EQ(array[5], "text"); + EXPECT_EQ(array[5], u8"text"); } TEST(JsonParser, deserialize_array_nested) { @@ -174,11 +174,11 @@ TEST(JsonParser, deserialize_array_nested) { EXPECT_EQ(array[4].size(), 0U); EXPECT_FALSE(array[5].null()); ASSERT_EQ(array[5].size(), 1U); - EXPECT_EQ(array[5], std::vector{ " text " }); - EXPECT_EQ(array[5], std::vector{ " text " }); + EXPECT_EQ(array[5], std::vector{ u8" text " }); + EXPECT_EQ(array[5], std::vector{ u8" text " }); EXPECT_DOUBLE_EQ(array[6].get(), 12.34); EXPECT_DOUBLE_EQ(array[7].get(), 0.1234); - EXPECT_EQ(array[8], "text"); + EXPECT_EQ(array[8], u8"text"); auto nested_array = array[3].get>(); ASSERT_EQ(nested_array.size(), 6U); @@ -186,7 +186,7 @@ TEST(JsonParser, deserialize_array_nested) { EXPECT_EQ(nested_array[1], 2); EXPECT_EQ(nested_array[2], 3); EXPECT_TRUE(nested_array[3].null()); - EXPECT_EQ(nested_array[4], "text"); + EXPECT_EQ(nested_array[4],u8"text"); std::vector expected{ 5, 6, 7 }; EXPECT_EQ(nested_array[5], expected); } @@ -205,12 +205,12 @@ TEST(JsonParser, deserialize_map) { object obj = parser.deserialize(json_data); EXPECT_EQ(obj.size(), 6U); - EXPECT_EQ(obj["some_true"], true); - EXPECT_EQ(obj["some_false"], false); - EXPECT_EQ(obj["some_int"], 1234); - EXPECT_DOUBLE_EQ(obj["some_double"].get(), 12.34); - EXPECT_DOUBLE_EQ(obj["some_other_double"].get(), 0.1234); - EXPECT_EQ(obj["some_text"], "text"); + EXPECT_EQ(obj[u8"some_true"], true); + EXPECT_EQ(obj[u8"some_false"], false); + EXPECT_EQ(obj[u8"some_int"], 1234); + EXPECT_DOUBLE_EQ(obj[u8"some_double"].get(), 12.34); + EXPECT_DOUBLE_EQ(obj[u8"some_other_double"].get(), 0.1234); + EXPECT_EQ(obj[u8"some_text"], u8"text"); } TEST(JsonParser, deserialize_map_nested) { @@ -233,21 +233,21 @@ TEST(JsonParser, deserialize_map_nested) { object obj = parser.deserialize(json_data); EXPECT_EQ(obj.size(), 4U); - EXPECT_EQ(obj["some_text"], "text"); - EXPECT_EQ(obj["some other text"], " asdf "); + EXPECT_EQ(obj[u8"some_text"], u8"text"); + EXPECT_EQ(obj[u8"some other text"], u8" asdf "); // some_object - EXPECT_FALSE(obj["some_object"].null()); - EXPECT_EQ(obj["some_object"].size(), 1U); - EXPECT_FALSE(obj["some_object"]["some_null_object"].null()); - EXPECT_EQ(obj["some_object"]["some_null_object"].size(), 0U); + EXPECT_FALSE(obj[u8"some_object"].null()); + EXPECT_EQ(obj[u8"some_object"].size(), 1U); + EXPECT_FALSE(obj[u8"some_object"][u8"some_null_object"].null()); + EXPECT_EQ(obj[u8"some_object"][u8"some_null_object"].size(), 0U); // some_other_object - EXPECT_FALSE(obj["some_other_object"].null()); - EXPECT_EQ(obj["some_other_object"].size(), 1U); - EXPECT_FALSE(obj["some_other_object"]["beans"].null()); - EXPECT_EQ(obj["some_other_object"]["beans"].size(), 3U); - EXPECT_EQ(obj["some_other_object"]["beans"]["fruit"], true); - EXPECT_EQ(obj["some_other_object"]["beans"]["magical"], true); - EXPECT_EQ(obj["some_other_object"]["beans"]["makes toot"], true); + EXPECT_FALSE(obj[u8"some_other_object"].null()); + EXPECT_EQ(obj[u8"some_other_object"].size(), 1U); + EXPECT_FALSE(obj[u8"some_other_object"][u8"beans"].null()); + EXPECT_EQ(obj[u8"some_other_object"][u8"beans"].size(), 3U); + EXPECT_EQ(obj[u8"some_other_object"][u8"beans"][u8"fruit"], true); + EXPECT_EQ(obj[u8"some_other_object"][u8"beans"][u8"magical"], true); + EXPECT_EQ(obj[u8"some_other_object"][u8"beans"][u8"makes toot"], true); }