From 53991992901e30de879f7b520c0e4eb1041b1058 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Sat, 11 Jul 2020 20:19:02 +0100 Subject: [PATCH] Initial incomplete code --- include/etl/private/string_utilities_helper.h | 433 ++++++++++++++++++ include/etl/string_utilities.h | 401 ++++++++++++++++ test/data.h | 4 +- test/test_string_utilities_char.cpp | 320 +++++++++++++ test/vs2019/etl.vcxproj | 3 + test/vs2019/etl.vcxproj.filters | 9 + 6 files changed, 1168 insertions(+), 2 deletions(-) create mode 100644 include/etl/private/string_utilities_helper.h create mode 100644 include/etl/string_utilities.h create mode 100644 test/test_string_utilities_char.cpp diff --git a/include/etl/private/string_utilities_helper.h b/include/etl/private/string_utilities_helper.h new file mode 100644 index 00000000..06449d21 --- /dev/null +++ b/include/etl/private/string_utilities_helper.h @@ -0,0 +1,433 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2020 John Wellbelove, John Lagerquist + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_STRING_UTILITIES_HELPER_INCLUDED +#define ETL_STRING_UTILITIES_HELPER_INCLUDED + +#include "../platform.h" +#include "../basic_string.h" +#include "../string_view.h" +#include "../algorithm.h" + +#include + +namespace etl +{ + namespace private_string_utilities + { + //*************************************************************************** + /// trim_left + /// Trim left of whitespace + //*************************************************************************** + template + void trim_left_of(TIString& s, typename TIString::const_pointer trim_characters) + { + size_t position = s.find_first_not_of(trim_characters); + s.erase(0U, position); + } + + //*************************************************************************** + /// trim_left + /// Trim left, up to, but not including, delimiters. + //*************************************************************************** + template + void trim_left_delimiters(TIString& s, typename TIString::const_pointer delimiters) + { + size_t p = s.find_first_of(delimiters); + + if (p != TIString::npos) + { + s.erase(0, p); + } + } + + //*************************************************************************** + /// trim_left + /// Trim left, up to, but not including, delimiters. + //*************************************************************************** + template + void trim_left_delimiters(TIString& s, typename TIString::const_pointer delimiters, size_t length) + { + size_t p = s.find_first_of(delimiters, 0, length); + + if (p != TIString::npos) + { + s.erase(0, p); + } + } + + //*************************************************************************** + /// trim_left + /// Trim left, up to, but not including, delimiters. + //*************************************************************************** + template + void trim_left_delimiters(TIString& s, const TIString& delimiters) + { + trim_left_delimiters(s, delimiters.c_str()); + } + + //*************************************************************************** + /// trim_right + /// Trim right of whitespace + //*************************************************************************** + template + void trim_right_of(TIString& s, typename TIString::const_pointer trim_characters) + { + s.erase(s.find_last_not_of(trim_characters) + 1); + } + + //*************************************************************************** + /// trim_right + //*************************************************************************** + template + void trim_right_delimiters(TIString& s, typename TIString::const_pointer delimiters) + { + size_t p = s.find_last_of(delimiters); + + if (p != TIString::npos) + { + ++p; + + if (p != s.size()) + { + s.erase(p); + } + } + } + + //*************************************************************************** + /// trim_right + /// Trim right, up to, but not including, delimiters. + //*************************************************************************** + template + void trim_right_delimiters(TIString& s, typename TIString::const_pointer delimiters, size_t length) + { + size_t p = s.find_last_of(delimiters, TIString::npos, length); + + if (p != TIString::npos) + { + ++p; + + if (p != s.size()) + { + s.erase(p); + } + } + } + + //*************************************************************************** + /// trim_right + /// Trim right, up to, but not including, delimiters. + //*************************************************************************** + template + void trim_right_delimiters(TIString& s, const TIString& delimiters) + { + trim_right(s, delimiters.c_str()); + } + + //*************************************************************************** + /// trim + /// Trim left and right of whitespace + //*************************************************************************** + template + void trim_of(TIString& s, typename TIString::const_pointer trim_characters) + { + trim_left_of(s, trim_characters); + trim_right_of(s, trim_characters); + } + + ////*************************************************************************** + ///// trim_view + ///// return a string view trimmed left and right of whitespace + ////*************************************************************************** + //static TStringView trim_view(TIString& s) + //{ + // size_t first = s.find_first_not_of(whitespace()); + // size_t last = s.find_last_not_of(whitespace()); + + // typename TIString::const_pointer pbegin; + // typename TIString::const_pointer pend; + + // if (first == TIString::npos) + // { + // pbegin = s.end(); + // } + // else + // { + // pbegin = s.c_str() + first; + // } + + // if (last == TIString::npos) + // { + // pend = s.end(); + // } + // else + // { + // pend = s.c_str() + last + 1; + // } + + // return TStringView(pbegin, pend); + //} + + ////*************************************************************************** + ///// reverse + ///// Reverse a string + ////*************************************************************************** + //void reverse(TIString& s) + //{ + // etl::reverse(s.begin(), s.end()); + //} + + ////*************************************************************************** + ///// + ////*************************************************************************** + //template + //etl::string left(etl::string const& s, size_t n_chars) + //{ + // return s.substr(0, n_chars); + //} + + ////*************************************************************************** + ///// + ////*************************************************************************** + //template + //etl::string right(etl::string const& s, size_t start) + //{ + // return s.substr(start); + //} + + //template + //void tokenize(etl::string const& s, etl::vector, max_num_tokens>& tokens, char const* delims, bool ignore_empty_strings) + //{ + // size_t delim; + // size_t O = 0; + + // tokens.clear(); + + // delim = s.find_first_of(delims, O); + + // while (delim != etl::string::npos) + // { + // etl::string tok(s.substr(O, delim - O)); + // trim(tok); + // if (!tok.empty() || !ignore_empty_strings) + // tokens.push_back(tok); + // O = delim + 1; + + // delim = s.find_first_of(delims, O); + // } + // etl::string tok(s.substr(O)); + // trim(tok); + // if (!tok.empty() || !ignore_empty_strings) + // tokens.push_back(tok); + //} + + //template + //void tokenize(etl::string const& s, etl::vector, max_num_tokens>& tokens, char const* delims, bool ignore_empty_strings) + //{ + // size_t delim; + // size_t O = 0; + + // tokens.clear(); + + // delim = s.find_first_of(delims, O); + + // while (delim != etl::string::npos) + // { + // etl::string tok(s.substr(O, delim - O).c_str()); + // trim(tok); + // if (!tok.empty() || !ignore_empty_strings) + // tokens.push_back(tok); + // O = delim + 1; + + // delim = s.find_first_of(delims, O); + // } + // etl::string tok(s.substr(O).c_str()); + // trim(tok); + // if (!tok.empty() || !ignore_empty_strings) + // tokens.push_back(tok); + //} + + //template + //float to_float(etl::string const& s) + //{ + // return strtof(s.c_str(), 0); + //} + + //template + //unsigned to_unsigned(etl::string const& s, int radix) + //{ + // return strtoul(s.c_str(), 0, radix); + //} + + //template + //int to_int(etl::string const& s, int radix) + //{ + // return strtol(s.c_str(), 0, radix); + //} + + //template + //bool to_bool(etl::string const& s) + //{ + // return s[0] == 't' || s[0] == 'T'; + //} + + //template + //etl::string substr_between(etl::string const& s, const etl::string brackets) + //{ + // size_t l = s.find_first_of(brackets[0]); + // size_t r = s.find_last_of(brackets[1]); + + // if (l != etl::string::npos && r != etl::string::npos && r - l > 1) + // return s.substr(l + 1, r - l - 1); + // return etl::string(); + //} + + //template + //int array_subscript(etl::string const& s) + //{ + // etl::string n = substr_between(s); + // return n.empty() ? -1 : to_int(n); + //} + + //template + //etl::string from_float(float f, int digits) + //{ + // char buf[32]; + // char format[] = { '%','9','.',char('0' + char(digits)),'f',0 }; + // sprintf(buf, format, f); + // return etl::string(buf); + //} + + //template + //etl::string from_float(float f, char const* format_string) + //{ + // char buf[32]; + // sprintf(buf, format_string, f); + // return etl::string(buf); + //} + + //template + //etl::string from_unsigned(unsigned u, bool hex = false) + //{ + // char buf[16]; + // char format[] = { '%',hex ? 'x' : 'u',0 }; + // sprintf(buf, format, u); + // return etl::string(buf); + //} + + //template + //etl::string from_int(int i, bool hex = false) + //{ + // char buf[16]; + // char format[] = { '%',hex ? 'x' : 'i',0 }; + // sprintf(buf, format, i); + // return etl::string(buf); + //} + + //template + //etl::string from_bool(bool b, bool verbose) + //{ + // if (verbose) + // return b ? "true" : "false"; + // else + // return b ? "t" : "f"; + //} + + + //template + //void reverse(etl::string& s) + //{ + // std::reverse(s.begin(), s.end()); + //} + + //enum pad_dir_t + //{ + // pad_dir__right, + // pad_dir__left + //}; + + //template + //void pad(etl::string& s, size_t size, pad_dir_t dir, char pad_char) + //{ + // if (size > s.size()) + // { + // size -= s.size(); + + // if (dir == pad_dir__left) + // { + // reverse(s); + // s.reserve(s.size() + size); + // while (size--) + // s.push_back(pad_char); + // reverse(s); + // } + // else + // { + // s.reserve(s.size() + size); + // while (size--) + // s.push_back(pad_char); + // } + // } + //} + + //template + //void to_uppercase(etl::string& s) + //{ + // for (typename etl::string::iterator iter = s.begin(); iter != s.end(); ++iter) + // *iter = char(toupper(*iter)); + //} + + //template + //void to_lowercase(etl::string& s) + //{ + // for (typename etl::string::iterator iter = s.begin(); iter != s.end(); ++iter) + // *iter = char(tolower(*iter)); + //} + + //template + //void namify(etl::string& s) + //{ + // replace(s.begin(), s.end(), ' ', '_'); + // replace(s.begin(), s.end(), '/', '_'); + // replace(s.begin(), s.end(), '-', '_'); + // replace(s.begin(), s.end(), '.', '_'); + // replace(s.begin(), s.end(), '(', '_'); + // replace(s.begin(), s.end(), ')', '_'); + // replace(s.begin(), s.end(), ',', '_'); + // replace(s.begin(), s.end(), '[', '_'); + // replace(s.begin(), s.end(), ']', '_'); + // while (!s.empty() && s.back() == '_') + // s.pop_back(); + //} + }; +} + +#endif \ No newline at end of file diff --git a/include/etl/string_utilities.h b/include/etl/string_utilities.h new file mode 100644 index 00000000..18000a7c --- /dev/null +++ b/include/etl/string_utilities.h @@ -0,0 +1,401 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2020 John Wellbelove, John Lagerquist + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_STRING_UTILITIES_INCLUDED +#define ETL_STRING_UTILITIES_INCLUDED + +#include "platform.h" +#include "cstring.h" +#include "string_view.h" +#include "private/string_utilities_helper.h" + +namespace etl +{ + //*************************************************************************** + /// trim_left + /// Trim left of whitespace + //*************************************************************************** + static void trim_left(etl::istring& s) + { + etl::private_string_utilities::trim_left_of(s, " \t\n\r\f\v"); + } + + //*************************************************************************** + /// trim_left_of + /// Trim left of specified characters + //*************************************************************************** + static void trim_left_of(etl::istring& s, etl::istring::const_pointer trim_characters) + { + etl::private_string_utilities::trim_left_of(s, trim_characters); + } + + //*************************************************************************** + /// trim_left + /// Trim left, up to, but not including, delimiters. + //*************************************************************************** + static void trim_left(etl::istring& s, etl::istring::const_pointer delimiters) + { + etl::private_string_utilities::trim_left_delimiters(s, delimiters); + } + + //*************************************************************************** + /// trim_left + /// Trim left, up to, but not including, delimiters. + //*************************************************************************** + static void trim_left(etl::istring& s, etl::istring::const_pointer delimiters, size_t length) + { + etl::private_string_utilities::trim_left_delimiters(s, delimiters, length); + } + + //*************************************************************************** + /// trim_left + /// Trim left, up to, but not including, delimiters. + //*************************************************************************** + static void trim_left(etl::istring& s, const etl::string_view& delimiters) + { + etl::private_string_utilities::trim_left_delimiters(s, delimiters.begin(), delimiters.size()); + } + + //*************************************************************************** + /// trim_left + /// Trim left, up to, but not including, delimiters. + //*************************************************************************** + static void trim_left(etl::istring& s, const etl::istring& delimiters) + { + etl::private_string_utilities::trim_left_delimiters(s, delimiters.c_str()); + } + + //*************************************************************************** + /// trim_right + /// Trim right of whitespace + //*************************************************************************** + static void trim_right(etl::istring& s) + { + etl::private_string_utilities::trim_right_of(s, " \t\n\r\f\v"); + } + + //*************************************************************************** + /// trim_right_of + /// Trim right of specified characters + //*************************************************************************** + static void trim_right_of(etl::istring& s, etl::istring::const_pointer trim_characters) + { + etl::private_string_utilities::trim_right_of(s, trim_characters); + } + + //*************************************************************************** + /// trim_right + //*************************************************************************** + static void trim_right(etl::istring& s, etl::istring::const_pointer delimiters) + { + etl::private_string_utilities::trim_right_delimiters(s, delimiters); + } + + //*************************************************************************** + /// trim_right + /// Trim right, up to, but not including, delimiters. + //*************************************************************************** + static void trim_right(etl::istring& s, etl::istring::const_pointer delimiters, size_t length) + { + etl::private_string_utilities::trim_right_delimiters(s, delimiters, length); + } + + //*************************************************************************** + /// trim_right + /// Trim right, up to, but not including, delimiters. + //*************************************************************************** + static void trim_right(etl::istring& s, const etl::istring& delimiters) + { + etl::private_string_utilities::trim_right_delimiters(s, delimiters.c_str()); + } + + //*************************************************************************** + /// trim_right + /// Trim right, up to, but not including, delimiters. + //*************************************************************************** + static void trim_right(etl::istring& s, const etl::string_view& delimiters) + { + etl::private_string_utilities::trim_right_delimiters(s, delimiters.begin(), delimiters.size()); + } + + //*************************************************************************** + /// trim + /// Trim left and right of whitespace + //*************************************************************************** + void trim(etl::istring& s) + { + etl::private_string_utilities::trim_of(s, " \t\n\r\f\v"); + } + + ////*************************************************************************** + ///// trim_view + ///// Trim left and right of whitespace + ////*************************************************************************** + //etl::string_view trim_view(etl::istring& s) + //{ + // return etl::private_string_utilities::trim_view(s); + //} + + ////*************************************************************************** + ///// reverse + ///// Reverse the string + ////*************************************************************************** + //void reverse(etl::istring& s) + //{ + // etl::private_string_utilities::reverse(s); + //} + + ////*************************************************************************** + ///// + ////*************************************************************************** + //template + //etl::string left(etl::string const& s, size_t n_chars) + //{ + // return s.substr(0, n_chars); + //} + + ////*************************************************************************** + ///// + ////*************************************************************************** + //template + //etl::string right(etl::string const& s, size_t start) + //{ + // return s.substr(start); + //} + + //template + //void tokenize(etl::string const& s, etl::vector, max_num_tokens>& tokens, char const* delims, bool ignore_empty_strings) + //{ + // size_t delim; + // size_t O = 0; + + // tokens.clear(); + + // delim = s.find_first_of(delims, O); + + // while (delim != etl::string::npos) + // { + // etl::string tok(s.substr(O, delim - O)); + // trim(tok); + // if (!tok.empty() || !ignore_empty_strings) + // tokens.push_back(tok); + // O = delim + 1; + + // delim = s.find_first_of(delims, O); + // } + // etl::string tok(s.substr(O)); + // trim(tok); + // if (!tok.empty() || !ignore_empty_strings) + // tokens.push_back(tok); + //} + + //template + //void tokenize(etl::string const& s, etl::vector, max_num_tokens>& tokens, char const* delims, bool ignore_empty_strings) + //{ + // size_t delim; + // size_t O = 0; + + // tokens.clear(); + + // delim = s.find_first_of(delims, O); + + // while (delim != etl::string::npos) + // { + // etl::string tok(s.substr(O, delim - O).c_str()); + // trim(tok); + // if (!tok.empty() || !ignore_empty_strings) + // tokens.push_back(tok); + // O = delim + 1; + + // delim = s.find_first_of(delims, O); + // } + // etl::string tok(s.substr(O).c_str()); + // trim(tok); + // if (!tok.empty() || !ignore_empty_strings) + // tokens.push_back(tok); + //} + + //template + //float to_float(etl::string const& s) + //{ + // return strtof(s.c_str(), 0); + //} + + //template + //unsigned to_unsigned(etl::string const& s, int radix) + //{ + // return strtoul(s.c_str(), 0, radix); + //} + + //template + //int to_int(etl::string const& s, int radix) + //{ + // return strtol(s.c_str(), 0, radix); + //} + + //template + //bool to_bool(etl::string const& s) + //{ + // return s[0] == 't' || s[0] == 'T'; + //} + + //template + //etl::string substr_between(etl::string const& s, const etl::string brackets) + //{ + // size_t l = s.find_first_of(brackets[0]); + // size_t r = s.find_last_of(brackets[1]); + + // if (l != etl::string::npos && r != etl::string::npos && r - l > 1) + // return s.substr(l + 1, r - l - 1); + // return etl::string(); + //} + + //template + //int array_subscript(etl::string const& s) + //{ + // etl::string n = substr_between(s); + // return n.empty() ? -1 : to_int(n); + //} + + //template + //etl::string from_float(float f, int digits) + //{ + // char buf[32]; + // char format[] = { '%','9','.',char('0' + char(digits)),'f',0 }; + // sprintf(buf, format, f); + // return etl::string(buf); + //} + + //template + //etl::string from_float(float f, char const* format_string) + //{ + // char buf[32]; + // sprintf(buf, format_string, f); + // return etl::string(buf); + //} + + //template + //etl::string from_unsigned(unsigned u, bool hex = false) + //{ + // char buf[16]; + // char format[] = { '%',hex ? 'x' : 'u',0 }; + // sprintf(buf, format, u); + // return etl::string(buf); + //} + + //template + //etl::string from_int(int i, bool hex = false) + //{ + // char buf[16]; + // char format[] = { '%',hex ? 'x' : 'i',0 }; + // sprintf(buf, format, i); + // return etl::string(buf); + //} + + //template + //etl::string from_bool(bool b, bool verbose) + //{ + // if (verbose) + // return b ? "true" : "false"; + // else + // return b ? "t" : "f"; + //} + + + //template + //void reverse(etl::string& s) + //{ + // std::reverse(s.begin(), s.end()); + //} + + //enum pad_dir_t + //{ + // pad_dir__right, + // pad_dir__left + //}; + + //template + //void pad(etl::string& s, size_t size, pad_dir_t dir, char pad_char) + //{ + // if (size > s.size()) + // { + // size -= s.size(); + + // if (dir == pad_dir__left) + // { + // reverse(s); + // s.reserve(s.size() + size); + // while (size--) + // s.push_back(pad_char); + // reverse(s); + // } + // else + // { + // s.reserve(s.size() + size); + // while (size--) + // s.push_back(pad_char); + // } + // } + //} + + //template + //void to_uppercase(etl::string& s) + //{ + // for (typename etl::string::iterator iter = s.begin(); iter != s.end(); ++iter) + // *iter = char(toupper(*iter)); + //} + + //template + //void to_lowercase(etl::string& s) + //{ + // for (typename etl::string::iterator iter = s.begin(); iter != s.end(); ++iter) + // *iter = char(tolower(*iter)); + //} + + //template + //void namify(etl::string& s) + //{ + // replace(s.begin(), s.end(), ' ', '_'); + // replace(s.begin(), s.end(), '/', '_'); + // replace(s.begin(), s.end(), '-', '_'); + // replace(s.begin(), s.end(), '.', '_'); + // replace(s.begin(), s.end(), '(', '_'); + // replace(s.begin(), s.end(), ')', '_'); + // replace(s.begin(), s.end(), ',', '_'); + // replace(s.begin(), s.end(), '[', '_'); + // replace(s.begin(), s.end(), ']', '_'); + // while (!s.empty() && s.back() == '_') + // s.pop_back(); + //} +} + +#undef ETL_ENABLE_IF_STRING + +#endif \ No newline at end of file diff --git a/test/data.h b/test/data.h index a40f739a..094bbec3 100644 --- a/test/data.h +++ b/test/data.h @@ -185,7 +185,7 @@ public: { } - TestDataM(TestDataM&& other) + TestDataM(TestDataM&& other) noexcept : value(other.value) , valid(true) { @@ -197,7 +197,7 @@ public: { } - TestDataM& operator =(TestDataM&& other) + TestDataM& operator =(TestDataM&& other) noexcept { value = std::move(other.value); valid = true; diff --git a/test/test_string_utilities_char.cpp b/test/test_string_utilities_char.cpp new file mode 100644 index 00000000..8bb8af0a --- /dev/null +++ b/test/test_string_utilities_char.cpp @@ -0,0 +1,320 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2020 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#include "UnitTest++/UnitTest++.h" + +#include "etl/cstring.h" +#include "etl/string_view.h" +#include "etl/string_utilities.h" + +#undef STR +#define STR(x) x + +namespace +{ + SUITE(test_string_utilities_char) + { + static const size_t SIZE = 50; + + typedef etl::string String; + typedef etl::istring IString; + typedef etl::string_view StringView; + + //************************************************************************* + TEST(test_trim_left_empty) + { + String text(STR("")); + String expected(STR("")); + + etl::trim_left(text); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left) + { + String text(STR(" \t\n\r\f\vHello World \t\n\r\f\v ")); + String expected(STR("Hello World \t\n\r\f\v ")); + + etl::trim_left(text); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_nothing_to_trim) + { + String text(STR("Hello World \t\n\r\f\v ")); + String expected(STR("Hello World \t\n\r\f\v ")); + + etl::trim_left(text); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_pointer_delimiters) + { + String text(STR("qztfpHello Worldqztfp")); + String expected(STR("Hello Worldqztfp")); + + etl::trim_left(text, STR("Hel")); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_pointer_delimiters_nothing_to_trim) + { + String text(STR("Hello Worldqztfp")); + String expected(STR("Hello Worldqztfp")); + + etl::trim_left(text, STR("Hel")); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_string_delimiters) + { + String text(STR("qztfpHello Worldqztfp")); + String expected("Hello Worldqztfp"); + + etl::trim_left(text, String(STR("Hel"))); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_string_delimiters_nothing_to_trim) + { + String text(STR("Hello Worldqztfp")); + String expected("Hello Worldqztfp"); + + etl::trim_left(text, String(STR("Hel"))); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_string_view_pointer_delimiters) + { + String text(STR("qztfpHello Worldqztfp")); + String expected("Hello Worldqztfp"); + StringView view("Hel"); + + etl::trim_left(text, view.begin(), view.size()); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_string_view_pointer_delimiters_nothing_to_trim) + { + String text(STR("Hello Worldqztfp")); + String expected("Hello Worldqztfp"); + StringView view("Hel"); + + etl::trim_left(text, view); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_string_view_delimiters) + { + String text(STR("qztfpHello Worldqztfp")); + String expected("Hello Worldqztfp"); + StringView view("Hel"); + + etl::trim_left(text, view); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_left_string_view_delimiters_nothing_to_trim) + { + String text(STR("Hello Worldqztfp")); + String expected("Hello Worldqztfp"); + StringView view("Hel"); + + etl::trim_left(text, view.begin(), view.size()); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_right) + { + String text(STR(" \t\n\r\f\vHello World \t\n\r\f\v ")); + String expected(STR(" \t\n\r\f\vHello World")); + + etl::trim_right(text); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_right_nothing_to_trim) + { + String text(STR(" \t\n\r\f\vHello World")); + String expected(STR(" \t\n\r\f\vHello World")); + + etl::trim_right(text); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_right_pointer_delimiters) + { + String text(STR("qztfpHello Worldqztfp")); + String expected(STR("qztfpHello World")); + + etl::trim_right(text, "rld"); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_right_pointer_delimiters_nothing_to_trim) + { + String text(STR("qztfpHello World")); + String expected(STR("qztfpHello World")); + + etl::trim_right(text, "rld"); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_right_string_delimiters) + { + String text(STR("qztfpHello Worldqztfp")); + String expected("qztfpHello World"); + + etl::trim_right(text, String(STR("rld"))); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_right_string_delimiters_nothing_to_trim) + { + String text(STR("qztfpHello Worldq")); + String expected("qztfpHello World"); + + etl::trim_right(text, String(STR("rld"))); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_right_string_view_delimiters) + { + String text(STR("qztfpHello Worldqztfp")); + String expected("qztfpHello World"); + StringView view("rld"); + + etl::trim_right(text, view.begin(), view.size()); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_right_string_view_delimiters_nothing_to_trim) + { + String text(STR("qztfpHello World")); + String expected("qztfpHello World"); + StringView view("rld"); + + etl::trim_right(text, view.begin(), view.size()); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim) + { + String text(STR(" \t\n\r\f\vHello World \t\n\r\f\v ")); + String expected(STR("Hello World")); + + etl::trim(text); + + CHECK(expected == text); + } + + //************************************************************************* + TEST(test_trim_nothing_to_trim) + { + String text(STR("Hello World")); + String expected(STR("Hello World")); + + etl::trim(text); + + CHECK(expected == text); + } + + ////************************************************************************* + //TEST(test_trim_view) + //{ + // String text(STR(" \t\n\r\f\vHello World \t\n\r\f\v ")); + // String expected(STR("Hello World")); + + // StringView view = etl::trim_view(text); + + // String view_text(view.begin(), view.end()); + // CHECK(expected == view_text); + //} + + ////************************************************************************* + //TEST(test_trim_view_nothing_to_trim) + //{ + // String text(STR("Hello World")); + // String expected(STR("Hello World")); + + // StringView view = etl::trim_view(text); + + // String view_text(view.begin(), view.end()); + // CHECK(expected == view_text); + //} + + ////************************************************************************* + //TEST(test_reverse) + //{ + // String text(STR("Hello World")); + // String expected(STR("dlroW olleH")); + + // etl::reverse(text); + + // CHECK(expected == text); + //} + }; +} diff --git a/test/vs2019/etl.vcxproj b/test/vs2019/etl.vcxproj index 897f9c78..9aed630d 100644 --- a/test/vs2019/etl.vcxproj +++ b/test/vs2019/etl.vcxproj @@ -1063,6 +1063,7 @@ + @@ -1123,6 +1124,7 @@ + @@ -1628,6 +1630,7 @@ + diff --git a/test/vs2019/etl.vcxproj.filters b/test/vs2019/etl.vcxproj.filters index 1fbcaba3..e376a5df 100644 --- a/test/vs2019/etl.vcxproj.filters +++ b/test/vs2019/etl.vcxproj.filters @@ -870,6 +870,12 @@ ETL\Strings + + ETL\Strings + + + ETL\Private + @@ -1358,6 +1364,9 @@ Source Files + + Source Files +