ydb/util/generic/string_ut.cpp

#include "deque.h"
#include "strbuf.h"
#include "string_ut.h"
#include "vector.h"
#include "yexception.h"

#include <util/charset/wide.h>
#include <util/str_stl.h>
#include <util/stream/output.h>
#include <util/string/subst.h>

#include <string>
#include <sstream>
#include <algorithm>
#include <stdexcept>

#ifdef TSTRING_IS_STD_STRING
static_assert(sizeof(TString) == sizeof(std::string), "expect sizeof(TString) == sizeof(std::string)");
#else
static_assert(sizeof(TString) == sizeof(const char*), "expect sizeof(TString) == sizeof(const char*)");
#endif

class TStringTestZero: public TTestBase {
    UNIT_TEST_SUITE(TStringTestZero);
    UNIT_TEST(TestZero);
    UNIT_TEST_SUITE_END();

public:
    void TestZero() {
        const char data[] = "abc\0def\0";
        TString s(data, sizeof(data));
        UNIT_ASSERT(s.size() == sizeof(data));
        UNIT_ASSERT(s.StartsWith(s));
        UNIT_ASSERT(s.EndsWith(s));
        UNIT_ASSERT(s.Contains('\0'));

        const char raw_def[] = "def";
        const char raw_zero[] = "\0";
        TString def(raw_def, sizeof(raw_def) - 1);
        TString zero(raw_zero, sizeof(raw_zero) - 1);
        UNIT_ASSERT_EQUAL(4, s.find(raw_def));
        UNIT_ASSERT_EQUAL(4, s.find(def));
        UNIT_ASSERT_EQUAL(4, s.find_first_of(raw_def));
        UNIT_ASSERT_EQUAL(3, s.find_first_of(zero));
        UNIT_ASSERT_EQUAL(7, s.find_first_not_of(def, 4));

        const char nonSubstring[] = "def\0ghi";
        UNIT_ASSERT_EQUAL(TString::npos, s.find(TString(nonSubstring, sizeof(nonSubstring))));

        TString copy = s;
        copy.replace(copy.size() - 1, 1, "z");
        UNIT_ASSERT(s != copy);
        copy.replace(copy.size() - 1, 1, "\0", 0, 1);
        UNIT_ASSERT(s == copy);

        TString prefix(data, 5);
        UNIT_ASSERT(s.StartsWith(prefix));
        UNIT_ASSERT(s != prefix);
        UNIT_ASSERT(s > prefix);
        UNIT_ASSERT(s > s.data());
        UNIT_ASSERT(s == TString(s.data(), s.size()));
        UNIT_ASSERT(data < s);

        s.remove(5);
        UNIT_ASSERT(s == prefix);
    }
};

UNIT_TEST_SUITE_REGISTRATION(TStringTestZero);

template <typename TStringType, typename TTestData>
class TStringStdTestImpl {
    using TChar = typename TStringType::char_type;
    using TTraits = typename TStringType::traits_type;
    using TView = std::basic_string_view<TChar, TTraits>;

    TTestData Data_;

protected:
    void Constructor() {
        // @todo use UNIT_TEST_EXCEPTION
        try {
            TStringType s((size_t)-1, *Data_.a());
            UNIT_ASSERT(false);
        } catch (const std::length_error&) {
            UNIT_ASSERT(true);
        } catch (...) {
            //Expected exception is length_error:
            UNIT_ASSERT(false);
        }
    }

    void reserve() {
#if 0
        TStringType s;
        // @todo use UNIT_TEST_EXCEPTION
        try {
            s.reserve(s.max_size() + 1);
            UNIT_ASSERT(false);
        } catch (const std::length_error&) {
            UNIT_ASSERT(true);
        } catch (...) {
            //Expected exception is length_error:
            UNIT_ASSERT(false);
        }

        // Non-shared behaviour - never shrink

        s.reserve(256);
    #ifndef TSTRING_IS_STD_STRING
        const auto* data = s.data();

        UNIT_ASSERT(s.capacity() >= 256);

        s.reserve(128);

        UNIT_ASSERT(s.capacity() >= 256 && s.data() == data);
    #endif

        s.resize(64, 'x');
        s.reserve(10);

    #ifdef TSTRING_IS_STD_STRING
        UNIT_ASSERT(s.capacity() >= 64);
    #else
        UNIT_ASSERT(s.capacity() >= 256 && s.data() == data);
    #endif

    #ifndef TSTRING_IS_STD_STRING
        // Shared behaviour - always reallocate, just as much as requisted

        TStringType holder = s;

        UNIT_ASSERT(s.capacity() >= 256);

        s.reserve(128);

        UNIT_ASSERT(s.capacity() >= 128 && s.capacity() < 256 && s.data() != data);
        UNIT_ASSERT(s.IsDetached());

        s.resize(64, 'x');
        data = s.data();
        holder = s;

        s.reserve(10);

        UNIT_ASSERT(s.capacity() >= 64 && s.capacity() < 128 && s.data() != data);
        UNIT_ASSERT(s.IsDetached());
    #endif
#endif
    }

    void short_string() {
        TStringType const ref_short_str1(Data_.str1()), ref_short_str2(Data_.str2());
        TStringType short_str1(ref_short_str1), short_str2(ref_short_str2);
        TStringType const ref_long_str1(Data_.str__________________________________________________1());
        TStringType const ref_long_str2(Data_.str__________________________________________________2());
        TStringType long_str1(ref_long_str1), long_str2(ref_long_str2);

        UNIT_ASSERT(short_str1 == ref_short_str1);
        UNIT_ASSERT(long_str1 == ref_long_str1);

        {
            TStringType str1(short_str1);
            str1 = long_str1;
            UNIT_ASSERT(str1 == ref_long_str1);
        }

        {
            TStringType str1(long_str1);
            str1 = short_str1;
            UNIT_ASSERT(str1 == ref_short_str1);
        }

        {
            short_str1.swap(short_str2);
            UNIT_ASSERT((short_str1 == ref_short_str2) && (short_str2 == ref_short_str1));
            short_str1.swap(short_str2);
        }

        {
            long_str1.swap(long_str2);
            UNIT_ASSERT((long_str1 == ref_long_str2) && (long_str2 == ref_long_str1));
            long_str1.swap(long_str2);
        }

        {
            short_str1.swap(long_str1);
            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
            short_str1.swap(long_str1);
        }

        {
            long_str1.swap(short_str1);
            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
            long_str1.swap(short_str1);
        }

        {
            //This is to test move constructor
            TVector<TStringType> str_vect;

            str_vect.push_back(short_str1);
            str_vect.push_back(long_str1);
            str_vect.push_back(short_str2);
            str_vect.push_back(long_str2);

            UNIT_ASSERT(str_vect[0] == ref_short_str1);
            UNIT_ASSERT(str_vect[1] == ref_long_str1);
            UNIT_ASSERT(str_vect[2] == ref_short_str2);
            UNIT_ASSERT(str_vect[3] == ref_long_str2);
        }
    }

    void erase() {
        TChar const* c_str = Data_.Hello_World();
        TStringType str(c_str);
        UNIT_ASSERT(str == c_str);

        str.erase(str.begin() + 1, str.end() - 1); // Erase all but first and last.

        size_t i;
        for (i = 0; i < str.size(); ++i) {
            switch (i) {
                case 0:
                    UNIT_ASSERT(str[i] == *Data_.H());
                    break;

                case 1:
                    UNIT_ASSERT(str[i] == *Data_.d());
                    break;

                default:
                    UNIT_ASSERT(false);
            }
        }

        str.insert(1, c_str);
        str.erase(str.begin());   // Erase first element.
        str.erase(str.end() - 1); // Erase last element.
        UNIT_ASSERT(str == c_str);
        str.clear(); // Erase all.
        UNIT_ASSERT(str.empty());

        str = c_str;
        UNIT_ASSERT(str == c_str);

        str.erase(1, str.size() - 1); // Erase all but first and last.
        for (i = 0; i < str.size(); i++) {
            switch (i) {
                case 0:
                    UNIT_ASSERT(str[i] == *Data_.H());
                    break;

                case 1:
                    UNIT_ASSERT(str[i] == *Data_.d());
                    break;

                default:
                    UNIT_ASSERT(false);
            }
        }

        str.erase(1);
        UNIT_ASSERT(str == Data_.H());
    }

    void data() {
        TStringType xx;

        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 3
        UNIT_ASSERT(xx.data() != nullptr);
    }

    void c_str() {
        TStringType low(Data_._2004_01_01());
        TStringType xx;
        TStringType yy;

        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 1
        UNIT_ASSERT(*(yy.c_str()) == 0);

        // Blocks A and B should follow each other.
        // Block A:
        xx = Data_._123456();
        xx += low;
        UNIT_ASSERT(xx.c_str() == TView(Data_._1234562004_01_01()));
        // End of block A

        // Block B:
        xx = Data_._1234();
        xx += Data_._5();
        UNIT_ASSERT(xx.c_str() == TView(Data_._12345()));
        // End of block B
    }

    void null_char_of_empty() {
        const TStringType s;

        UNIT_ASSERT(s[s.size()] == 0);
    }

    void null_char() {
        // ISO/IEC 14882:1998(E), ISO/IEC 14882:2003(E), 21.3.4 ('... the const version')
        const TStringType s(Data_._123456());

        UNIT_ASSERT(s[s.size()] == 0);
    }

    // Allowed since C++17, see http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2475
    void null_char_assignment_to_subscript_of_empty() {
        TStringType s;

#ifdef TSTRING_IS_STD_STRING
        using reference = volatile typename TStringType::value_type&;
#else
        using reference = typename TStringType::reference;
#endif
        reference trailing_zero = s[s.size()];
        trailing_zero = 0;
        UNIT_ASSERT(trailing_zero == 0);
    }

    // Allowed since C++17, see http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2475
    void null_char_assignment_to_subscript_of_nonempty() {
        TStringType s(Data_._123456());

#ifdef TSTRING_IS_STD_STRING
        using reference = volatile typename TStringType::value_type&;
#else
        using reference = typename TStringType::reference;
#endif
        reference trailing_zero = s[s.size()];
        trailing_zero = 0;
        UNIT_ASSERT(trailing_zero == 0);
    }

#ifndef TSTRING_IS_STD_STRING
    // Dereferencing string end() is not allowed by C++ standard as of C++20, avoid using in real code.
    void null_char_assignment_to_end_of_empty() {
        TStringType s;

        volatile auto& trailing_zero = *(s.begin() + s.size());
        trailing_zero = 0;
        UNIT_ASSERT(trailing_zero == 0);
    }

    // Dereferencing string end() is not allowed by C++ standard as of C++20, avoid using in real code.
    void null_char_assignment_to_end_of_nonempty() {
        TStringType s(Data_._123456());

        volatile auto& trailing_zero = *(s.begin() + s.size());
        trailing_zero = 0;
        UNIT_ASSERT(trailing_zero == 0);
    }
#endif

    void insert() {
        TStringType strorg = Data_.This_is_test_string_for_string_calls();
        TStringType str;

        // In case of reallocation there is no auto reference problem
        // so we reserve a big enough TStringType to be sure to test this
        // particular point.

        str.reserve(100);
        str = strorg;

        //test self insertion:
        str.insert(10, str.c_str() + 5, 15);
        UNIT_ASSERT(str == Data_.This_is_teis_test_string_st_string_for_string_calls());

        str = strorg;
        str.insert(15, str.c_str() + 5, 25);
        UNIT_ASSERT(str == Data_.This_is_test_stis_test_string_for_stringring_for_string_calls());

        str = strorg;
        str.insert(0, str.c_str() + str.size() - 4, 4);
        UNIT_ASSERT(str == Data_.allsThis_is_test_string_for_string_calls());

        str = strorg;
        str.insert(0, str.c_str() + str.size() / 2 - 1, str.size() / 2 + 1);
        UNIT_ASSERT(str == Data_.ng_for_string_callsThis_is_test_string_for_string_calls());

        str = strorg;
        typename TStringType::iterator b = str.begin();
        typename TStringType::const_iterator s = str.begin() + str.size() / 2 - 1;
        typename TStringType::const_iterator e = str.end();
        str.insert(b, s, e);
        UNIT_ASSERT(str == Data_.ng_for_string_callsThis_is_test_string_for_string_calls());

#if 0
        // AV
        str = strorg;
        str.insert(str.begin(), str.begin() + str.size() / 2 - 1, str.end());
        UNIT_ASSERT(str == Data.ng_for_string_callsThis_is_test_string_for_string_calls());
#endif

        TStringType str0;
        str0.insert(str0.begin(), 5, *Data_._0());
        UNIT_ASSERT(str0 == Data_._00000());

        TStringType str1;
        {
            typename TStringType::size_type pos = 0, nb = 2;
            str1.insert(pos, nb, *Data_._1());
        }
        UNIT_ASSERT(str1 == Data_._11());

        str0.insert(0, str1);
        UNIT_ASSERT(str0 == Data_._1100000());

        TStringType str2(Data_._2345());
        str0.insert(str0.size(), str2, 1, 2);
        UNIT_ASSERT(str0 == Data_._110000034());

        str1.insert(str1.begin() + 1, 2, *Data_._2());
        UNIT_ASSERT(str1 == Data_._1221());

        str1.insert(2, Data_._333333(), 3);
        UNIT_ASSERT(str1 == Data_._1233321());

        str1.insert(4, Data_._4444());
        UNIT_ASSERT(str1 == Data_._12334444321());

        str1.insert(str1.begin() + 6, *Data_._5());
        UNIT_ASSERT(str1 == Data_._123344544321());
    }

    void resize() {
        TStringType s;

        s.resize(0);

        UNIT_ASSERT(*s.c_str() == 0);

        s = Data_._1234567();

        s.resize(0);
        UNIT_ASSERT(*s.c_str() == 0);

        s = Data_._1234567();
        s.resize(1);
        UNIT_ASSERT(s.size() == 1);
        UNIT_ASSERT(*s.c_str() == *Data_._1());
        UNIT_ASSERT(*(s.c_str() + 1) == 0);

        s = Data_._1234567();
#if 0
        s.resize(10);
#else
        s.resize(10, 0);
#endif
        UNIT_ASSERT(s.size() == 10);
        UNIT_ASSERT(s[6] == *Data_._7());
        UNIT_ASSERT(s[7] == 0);
        UNIT_ASSERT(s[8] == 0);
        UNIT_ASSERT(s[9] == 0);
    }

    void find() {
        TStringType s(Data_.one_two_three_one_two_three());

        UNIT_ASSERT(s.find(Data_.one()) == 0);
        UNIT_ASSERT(s.find(*Data_.t()) == 4);
        UNIT_ASSERT(s.find(*Data_.t(), 5) == 8);

        UNIT_ASSERT(s.find(Data_.four()) == TStringType::npos);
        UNIT_ASSERT(s.find(Data_.one(), TStringType::npos) == TStringType::npos);
        UNIT_ASSERT(s.find_first_of(Data_.abcde()) == 2);
        UNIT_ASSERT(s.find_first_not_of(Data_.enotw_()) == 9);
    }

    void capacity() {
        TStringType s;

        UNIT_ASSERT(s.capacity() < s.max_size());
        UNIT_ASSERT(s.capacity() >= s.size());

        for (int i = 0; i < 18; ++i) {
            s += ' ';

            UNIT_ASSERT(s.capacity() > 0);
            UNIT_ASSERT(s.capacity() < s.max_size());
            UNIT_ASSERT(s.capacity() >= s.size());
        }
    }

    void assign() {
        TStringType s;
        TChar const* cstr = Data_.test_string_for_assign();

        s.assign(cstr, cstr + 22);
        UNIT_ASSERT(s == Data_.test_string_for_assign());

        TStringType s2(Data_.other_test_string());
        s.assign(s2);
        UNIT_ASSERT(s == s2);

        static TStringType str1;
        static TStringType str2;

        // short TStringType optim:
        str1 = Data_._123456();
        // longer than short TStringType:
        str2 = Data_._1234567890123456789012345678901234567890();

        UNIT_ASSERT(str1[5] == *Data_._6());
        UNIT_ASSERT(str2[29] == *Data_._0());
    }

    void copy() {
        TStringType s(Data_.foo());
        TChar dest[4];
        dest[0] = dest[1] = dest[2] = dest[3] = 1;
        s.copy(dest, 4);
        int pos = 0;
        UNIT_ASSERT(dest[pos++] == *Data_.f());
        UNIT_ASSERT(dest[pos++] == *Data_.o());
        UNIT_ASSERT(dest[pos++] == *Data_.o());
        UNIT_ASSERT(dest[pos++] == 1);

        dest[0] = dest[1] = dest[2] = dest[3] = 1;
        s.copy(dest, 4, 2);
        pos = 0;
        UNIT_ASSERT(dest[pos++] == *Data_.o());
        UNIT_ASSERT(dest[pos++] == 1);

        // @todo use UNIT_TEST_EXCEPTION
        try {
            s.copy(dest, 4, 5);
            UNIT_ASSERT(!"expected std::out_of_range");
        } catch (const std::out_of_range&) {
            UNIT_ASSERT(true);
        } catch (...) {
            UNIT_ASSERT(!"expected std::out_of_range");
        }
    }

    void cbegin_cend() {
        const char helloThere[] = "Hello there";
        TString s = helloThere;
        size_t index = 0;
        for (auto it = s.cbegin(); s.cend() != it; ++it, ++index) {
            UNIT_ASSERT_VALUES_EQUAL(helloThere[index], *it);
        }
    }

    void compare() {
        TStringType str1(Data_.abcdef());
        TStringType str2;

        str2 = Data_.abcdef();
        UNIT_ASSERT(str1.compare(str2) == 0);
        UNIT_ASSERT(str1.compare(str2.data(), str2.size()) == 0);
        str2 = Data_.abcde();
        UNIT_ASSERT(str1.compare(str2) > 0);
        UNIT_ASSERT(str1.compare(str2.data(), str2.size()) > 0);
        str2 = Data_.abcdefg();
        UNIT_ASSERT(str1.compare(str2) < 0);
        UNIT_ASSERT(str1.compare(str2.data(), str2.size()) < 0);

        UNIT_ASSERT(str1.compare(Data_.abcdef()) == 0);
        UNIT_ASSERT(str1.compare(Data_.abcde()) > 0);
        UNIT_ASSERT(str1.compare(Data_.abcdefg()) < 0);

        str2 = Data_.cde();
        UNIT_ASSERT(str1.compare(2, 3, str2) == 0);
        str2 = Data_.cd();
        UNIT_ASSERT(str1.compare(2, 3, str2) > 0);
        str2 = Data_.cdef();
        UNIT_ASSERT(str1.compare(2, 3, str2) < 0);

        str2 = Data_.abcdef();
        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 3) == 0);
        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 2) > 0);
        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 4) < 0);

        UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 3) == 0);
        UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 2) > 0);
        UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 4) < 0);
    }

    void find_last_of() {
        // 21.3.6.4
        TStringType s(Data_.one_two_three_one_two_three());

        UNIT_ASSERT(s.find_last_of(Data_.abcde()) == 26);
        UNIT_ASSERT(s.find_last_of(TStringType(Data_.abcde())) == 26);

        TStringType test(Data_.aba());

        UNIT_ASSERT(test.find_last_of(Data_.a(), 2, 1) == 2);
        UNIT_ASSERT(test.find_last_of(Data_.a(), 1, 1) == 0);
        UNIT_ASSERT(test.find_last_of(Data_.a(), 0, 1) == 0);

        UNIT_ASSERT(test.find_last_of(*Data_.a(), 2) == 2);
        UNIT_ASSERT(test.find_last_of(*Data_.a(), 1) == 0);
        UNIT_ASSERT(test.find_last_of(*Data_.a(), 0) == 0);
    }
#if 0
    void rfind() {
        // 21.3.6.2
        TStringType s(Data.one_two_three_one_two_three());

        UNIT_ASSERT(s.rfind(Data.two()) == 18);
        UNIT_ASSERT(s.rfind(Data.two(), 0) == TStringType::npos);
        UNIT_ASSERT(s.rfind(Data.two(), 11) == 4);
        UNIT_ASSERT(s.rfind(*Data.w()) == 19);

        TStringType test(Data.aba());

        UNIT_ASSERT(test.rfind(Data.a(), 2, 1) == 2);
        UNIT_ASSERT(test.rfind(Data.a(), 1, 1) == 0);
        UNIT_ASSERT(test.rfind(Data.a(), 0, 1) == 0);

        UNIT_ASSERT(test.rfind(*Data.a(), 2) == 2);
        UNIT_ASSERT(test.rfind(*Data.a(), 1) == 0);
        UNIT_ASSERT(test.rfind(*Data.a(), 0) == 0);
    }
#endif
    void find_last_not_of() {
        // 21.3.6.6
        TStringType s(Data_.one_two_three_one_two_three());

        UNIT_ASSERT(s.find_last_not_of(Data_.ehortw_()) == 15);

        TStringType test(Data_.aba());

        UNIT_ASSERT(test.find_last_not_of(Data_.a(), 2, 1) == 1);
        UNIT_ASSERT(test.find_last_not_of(Data_.b(), 2, 1) == 2);
        UNIT_ASSERT(test.find_last_not_of(Data_.a(), 1, 1) == 1);
        UNIT_ASSERT(test.find_last_not_of(Data_.b(), 1, 1) == 0);
        UNIT_ASSERT(test.find_last_not_of(Data_.a(), 0, 1) == TStringType::npos);
        UNIT_ASSERT(test.find_last_not_of(Data_.b(), 0, 1) == 0);

        UNIT_ASSERT(test.find_last_not_of(*Data_.a(), 2) == 1);
        UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 2) == 2);
        UNIT_ASSERT(test.find_last_not_of(*Data_.a(), 1) == 1);
        UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 1) == 0);
        UNIT_ASSERT(test.find_last_not_of(*Data_.a(), 0) == TStringType::npos);
        UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 0) == 0);
    }
#if 0
    void replace() {
        // This test case is for the non template basic_TString::replace method,
        // this is why we play with the const iterators and reference to guaranty
        // that the right method is called.

        const TStringType v(Data._78());
        TStringType s(Data._123456());
        TStringType const& cs = s;

        typename TStringType::iterator i = s.begin() + 1;
        s.replace(i, i + 3, v.begin(), v.end());
        UNIT_ASSERT(s == Data._17856());

        s = Data._123456();
        i = s.begin() + 1;
        s.replace(i, i + 1, v.begin(), v.end());
        UNIT_ASSERT(s == Data._1783456());

        s = Data._123456();
        i = s.begin() + 1;
        typename TStringType::const_iterator ci = s.begin() + 1;
        s.replace(i, i + 3, ci + 3, cs.end());
        UNIT_ASSERT(s == Data._15656());

        s = Data._123456();
        i = s.begin() + 1;
        ci = s.begin() + 1;
        s.replace(i, i + 3, ci, ci + 2);
        UNIT_ASSERT(s == Data._12356());

        s = Data._123456();
        i = s.begin() + 1;
        ci = s.begin() + 1;
        s.replace(i, i + 3, ci + 1, cs.end());
        UNIT_ASSERT(s == Data._1345656());

        s = Data._123456();
        i = s.begin();
        ci = s.begin() + 1;
        s.replace(i, i, ci, ci + 1);
        UNIT_ASSERT(s == Data._2123456());

        s = Data._123456();
        s.replace(s.begin() + 4, s.end(), cs.begin(), cs.end());
        UNIT_ASSERT(s == Data._1234123456());

        // This is the test for the template replace method.

        s = Data._123456();
        typename TStringType::iterator b = s.begin() + 4;
        typename TStringType::iterator e = s.end();
        typename TStringType::const_iterator rb = s.begin();
        typename TStringType::const_iterator re = s.end();
        s.replace(b, e, rb, re);
        UNIT_ASSERT(s == Data._1234123456());

        s = Data._123456();
        s.replace(s.begin() + 4, s.end(), s.begin(), s.end());
        UNIT_ASSERT(s == Data._1234123456());

        TStringType strorg(Data.This_is_test_StringT_for_StringT_calls());
        TStringType str = strorg;
        str.replace(5, 15, str.c_str(), 10);
        UNIT_ASSERT(str == Data.This_This_is_tefor_StringT_calls());

        str = strorg;
        str.replace(5, 5, str.c_str(), 10);
        UNIT_ASSERT(str == Data.This_This_is_test_StringT_for_StringT_calls());

    #if !defined(STLPORT) || defined(_STLP_MEMBER_TEMPLATES)
        deque<TChar> cdeque;
        cdeque.push_back(*Data.I());
        str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end());
        UNIT_ASSERT(str == Data.Is_test_StringT_for_StringT_calls());
    #endif
    }
#endif
}; // TStringStdTestImpl

class TStringTest: public TTestBase, private TStringTestImpl<TString, TTestData<char>> {
public:
    UNIT_TEST_SUITE(TStringTest);
    UNIT_TEST(TestMaxSize);
    UNIT_TEST(TestConstructors);
    UNIT_TEST(TestReplace);
#ifndef TSTRING_IS_STD_STRING
    UNIT_TEST(TestRefCount);
#endif
    UNIT_TEST(TestFind);
    UNIT_TEST(TestContains);
    UNIT_TEST(TestOperators);
    UNIT_TEST(TestMulOperators);
    UNIT_TEST(TestFuncs);
    UNIT_TEST(TestUtils);
    UNIT_TEST(TestEmpty);
    UNIT_TEST(TestJoin);
    UNIT_TEST(TestCopy);
    UNIT_TEST(TestStrCpy);
    UNIT_TEST(TestPrefixSuffix);
#ifndef TSTRING_IS_STD_STRING
    UNIT_TEST(TestCharRef);
#endif
    UNIT_TEST(TestBack)
    UNIT_TEST(TestFront)
    UNIT_TEST(TestIterators);
    UNIT_TEST(TestReverseIterators);
    UNIT_TEST(TestAppendUtf16)
    UNIT_TEST(TestFillingAssign)
    UNIT_TEST(TestStdStreamApi)
    //UNIT_TEST(TestOperatorsCI); must fail
    UNIT_TEST_SUITE_END();

    void TestAppendUtf16() {
        TString appended = TString("А роза упала").AppendUtf16(u" на лапу Азора");
        UNIT_ASSERT(appended == "А роза упала на лапу Азора");
    }

    void TestFillingAssign() {
        TString s("abc");
        s.assign(5, 'a');
        UNIT_ASSERT_VALUES_EQUAL(s, "aaaaa");
    }

    void TestStdStreamApi() {
        const TString data = "abracadabra";
        std::stringstream ss;
        ss << data;

        UNIT_ASSERT_VALUES_EQUAL(data, ss.str());

        ss << '\n'
           << data << std::endl;

        TString read = "xxx";
        ss >> read;
        UNIT_ASSERT_VALUES_EQUAL(read, data);
    }
};

UNIT_TEST_SUITE_REGISTRATION(TStringTest);

class TWideStringTest: public TTestBase, private TStringTestImpl<TUtf16String, TTestData<wchar16>> {
public:
    UNIT_TEST_SUITE(TWideStringTest);
    UNIT_TEST(TestConstructors);
    UNIT_TEST(TestReplace);
#ifndef TSTRING_IS_STD_STRING
    UNIT_TEST(TestRefCount);
#endif
    UNIT_TEST(TestFind);
    UNIT_TEST(TestContains);
    UNIT_TEST(TestOperators);
    UNIT_TEST(TestLetOperator)
    UNIT_TEST(TestMulOperators);
    UNIT_TEST(TestFuncs);
    UNIT_TEST(TestUtils);
    UNIT_TEST(TestEmpty);
    UNIT_TEST(TestJoin);
    UNIT_TEST(TestCopy);
    UNIT_TEST(TestStrCpy);
    UNIT_TEST(TestPrefixSuffix);
#ifndef TSTRING_IS_STD_STRING
    UNIT_TEST(TestCharRef);
#endif
    UNIT_TEST(TestBack);
    UNIT_TEST(TestFront)
    UNIT_TEST(TestDecodingMethods);
    UNIT_TEST(TestIterators);
    UNIT_TEST(TestReverseIterators);
    UNIT_TEST(TestStringLiterals);
    UNIT_TEST_SUITE_END();

private:
    void TestDecodingMethods() {
        UNIT_ASSERT(TUtf16String::FromAscii("").empty());
        UNIT_ASSERT(TUtf16String::FromAscii("abc") == ASCIIToWide("abc"));

        const char* text = "123kx83abcd ej)#$%ddja&%J&";
        TUtf16String wtext = ASCIIToWide(text);

        UNIT_ASSERT(wtext == TUtf16String::FromAscii(text));

        TString strtext(text);
        UNIT_ASSERT(wtext == TUtf16String::FromAscii(strtext));

        TStringBuf strbuftext(text);
        UNIT_ASSERT(wtext == TUtf16String::FromAscii(strbuftext));

        UNIT_ASSERT(wtext.substr(5) == TUtf16String::FromAscii(text + 5));

        const wchar16 wideCyrillicAlphabet[] = {
            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
            0x00};

        TUtf16String strWide(wideCyrillicAlphabet);
        TString strUtf8 = WideToUTF8(strWide);

        UNIT_ASSERT(strWide == TUtf16String::FromUtf8(strUtf8.c_str()));
        UNIT_ASSERT(strWide == TUtf16String::FromUtf8(strUtf8));
        UNIT_ASSERT(strWide == TUtf16String::FromUtf8(TStringBuf(strUtf8)));

        // assign

        TUtf16String s1;
        s1.AssignAscii("1234");
        UNIT_ASSERT(s1 == ASCIIToWide("1234"));

        s1.AssignUtf8(strUtf8);
        UNIT_ASSERT(s1 == strWide);

        s1.AssignAscii(text);
        UNIT_ASSERT(s1 == wtext);

        // append

        TUtf16String s2;
        TUtf16String testAppend = strWide;
        s2.AppendUtf8(strUtf8);
        UNIT_ASSERT(testAppend == s2);

        testAppend += ' ';
        s2.AppendAscii(" ");
        UNIT_ASSERT(testAppend == s2);

        testAppend += '_';
        s2.AppendUtf8("_");
        UNIT_ASSERT(testAppend == s2);

        testAppend += wtext;
        s2.AppendAscii(text);
        UNIT_ASSERT(testAppend == s2);

        testAppend += wtext;
        s2.AppendUtf8(text);
        UNIT_ASSERT(testAppend == s2);
    }

    void TestLetOperator() {
        TUtf16String str;

        str = wchar16('X');
        UNIT_ASSERT(str == TUtf16String::FromAscii("X"));

        const TUtf16String hello = TUtf16String::FromAscii("hello");
        str = hello.data();
        UNIT_ASSERT(str == hello);

        str = hello;
        UNIT_ASSERT(str == hello);
    }

    void TestStringLiterals() {
        TUtf16String s1 = u"hello";
        UNIT_ASSERT_VALUES_EQUAL(s1, TUtf16String::FromAscii("hello"));

        TUtf16String s2 = u"привет";
        UNIT_ASSERT_VALUES_EQUAL(s2, TUtf16String::FromUtf8("привет"));
    }
};

UNIT_TEST_SUITE_REGISTRATION(TWideStringTest);

class TUtf32StringTest: public TTestBase, private TStringTestImpl<TUtf32String, TTestData<wchar32>> {
public:
    UNIT_TEST_SUITE(TUtf32StringTest);
    UNIT_TEST(TestConstructors);
    UNIT_TEST(TestReplace);
#ifndef TSTRING_IS_STD_STRING
    UNIT_TEST(TestRefCount);
#endif
    UNIT_TEST(TestFind);
    UNIT_TEST(TestContains);
    UNIT_TEST(TestOperators);
    UNIT_TEST(TestLetOperator)
    UNIT_TEST(TestMulOperators);
    UNIT_TEST(TestFuncs);
    UNIT_TEST(TestUtils);
    UNIT_TEST(TestEmpty);
    UNIT_TEST(TestJoin);
    UNIT_TEST(TestCopy);
    UNIT_TEST(TestStrCpy);
    UNIT_TEST(TestPrefixSuffix);
#ifndef TSTRING_IS_STD_STRING
    UNIT_TEST(TestCharRef);
#endif
    UNIT_TEST(TestBack);
    UNIT_TEST(TestFront)
    UNIT_TEST(TestDecodingMethods);
    UNIT_TEST(TestDecodingMethodsMixedStr);
    UNIT_TEST(TestIterators);
    UNIT_TEST(TestReverseIterators);
    UNIT_TEST(TestStringLiterals);
    UNIT_TEST_SUITE_END();

private:
    void TestDecodingMethods() {
        UNIT_ASSERT(TUtf32String::FromAscii("").empty());
        UNIT_ASSERT(TUtf32String::FromAscii("abc") == ASCIIToUTF32("abc"));

        const char* text = "123kx83abcd ej)#$%ddja&%J&";
        TUtf32String wtext = ASCIIToUTF32(text);

        UNIT_ASSERT(wtext == TUtf32String::FromAscii(text));

        TString strtext(text);
        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strtext));

        TStringBuf strbuftext(text);
        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strbuftext));

        UNIT_ASSERT(wtext.substr(5) == TUtf32String::FromAscii(text + 5));

        const wchar32 wideCyrillicAlphabet[] = {
            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
            0x00};

        TUtf32String strWide(wideCyrillicAlphabet);
        TString strUtf8 = WideToUTF8(strWide);

        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8.c_str()));
        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8));
        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(TStringBuf(strUtf8)));

        // assign

        TUtf32String s1;
        s1.AssignAscii("1234");
        UNIT_ASSERT(s1 == ASCIIToUTF32("1234"));

        s1.AssignUtf8(strUtf8);
        UNIT_ASSERT(s1 == strWide);

        s1.AssignAscii(text);
        UNIT_ASSERT(s1 == wtext);

        // append

        TUtf32String s2;
        TUtf32String testAppend = strWide;
        s2.AppendUtf8(strUtf8);
        UNIT_ASSERT(testAppend == s2);

        testAppend += ' ';
        s2.AppendAscii(" ");
        UNIT_ASSERT(testAppend == s2);

        testAppend += '_';
        s2.AppendUtf8("_");
        UNIT_ASSERT(testAppend == s2);

        testAppend += wtext;
        s2.AppendAscii(text);
        UNIT_ASSERT(testAppend == s2);

        testAppend += wtext;
        s2.AppendUtf8(text);

        UNIT_ASSERT(testAppend == s2);
    }

    void TestDecodingMethodsMixedStr() {
        UNIT_ASSERT(TUtf32String::FromAscii("").empty());
        UNIT_ASSERT(TUtf32String::FromAscii("abc") == ASCIIToUTF32("abc"));

        const char* text = "123kx83abcd ej)#$%ddja&%J&";
        TUtf32String wtext = ASCIIToUTF32(text);

        UNIT_ASSERT(wtext == TUtf32String::FromAscii(text));

        TString strtext(text);
        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strtext));

        TStringBuf strbuftext(text);
        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strbuftext));

        UNIT_ASSERT(wtext.substr(5) == TUtf32String::FromAscii(text + 5));

        const wchar32 cyrilicAndLatinWide[] = {
            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
            wchar32('z'),
            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
            wchar32('z'),
            0x00};

        TUtf32String strWide(cyrilicAndLatinWide);
        TString strUtf8 = WideToUTF8(strWide);

        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8.c_str()));
        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8));
        UNIT_ASSERT(strWide == UTF8ToUTF32<true>(strUtf8));
        UNIT_ASSERT(strWide == UTF8ToUTF32<false>(strUtf8));
        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(TStringBuf(strUtf8)));

        // assign

        TUtf32String s1;
        s1.AssignAscii("1234");
        UNIT_ASSERT(s1 == ASCIIToUTF32("1234"));

        s1.AssignUtf8(strUtf8);
        UNIT_ASSERT(s1 == strWide);

        s1.AssignAscii(text);
        UNIT_ASSERT(s1 == wtext);

        // append

        TUtf32String s2;
        TUtf32String testAppend = strWide;
        s2.AppendUtf16(UTF8ToWide(strUtf8));
        UNIT_ASSERT(testAppend == s2);

        testAppend += ' ';
        s2.AppendAscii(" ");
        UNIT_ASSERT(testAppend == s2);

        testAppend += '_';
        s2.AppendUtf8("_");
        UNIT_ASSERT(testAppend == s2);

        testAppend += wtext;
        s2.AppendAscii(text);
        UNIT_ASSERT(testAppend == s2);

        testAppend += wtext;
        s2.AppendUtf8(text);

        UNIT_ASSERT(testAppend == s2);
    }

    void TestLetOperator() {
        TUtf32String str;

        str = wchar32('X');
        UNIT_ASSERT(str == TUtf32String::FromAscii("X"));

        const TUtf32String hello = TUtf32String::FromAscii("hello");
        str = hello.data();
        UNIT_ASSERT(str == hello);

        str = hello;
        UNIT_ASSERT(str == hello);
    }

    void TestStringLiterals() {
        TUtf32String s1 = U"hello";
        UNIT_ASSERT_VALUES_EQUAL(s1, TUtf32String::FromAscii("hello"));

        TUtf32String s2 = U"привет";
        UNIT_ASSERT_VALUES_EQUAL(s2, TUtf32String::FromUtf8("привет"));
    }
};

UNIT_TEST_SUITE_REGISTRATION(TUtf32StringTest);

class TStringStdTest: public TTestBase, private TStringStdTestImpl<TString, TTestData<char>> {
public:
    UNIT_TEST_SUITE(TStringStdTest);
    UNIT_TEST(Constructor);
    UNIT_TEST(reserve);
    UNIT_TEST(short_string);
    UNIT_TEST(erase);
    UNIT_TEST(data);
    UNIT_TEST(c_str);
    UNIT_TEST(null_char_of_empty);
    UNIT_TEST(null_char);
    UNIT_TEST(null_char_assignment_to_subscript_of_empty);
    UNIT_TEST(null_char_assignment_to_subscript_of_nonempty);
#ifndef TSTRING_IS_STD_STRING
    UNIT_TEST(null_char_assignment_to_end_of_empty);
    UNIT_TEST(null_char_assignment_to_end_of_nonempty);
#endif
    UNIT_TEST(insert);
    UNIT_TEST(resize);
    UNIT_TEST(find);
    UNIT_TEST(capacity);
    UNIT_TEST(assign);
    UNIT_TEST(copy);
    UNIT_TEST(cbegin_cend);
    UNIT_TEST(compare);
    UNIT_TEST(find_last_of);
#if 0
        UNIT_TEST(rfind);
        UNIT_TEST(replace);
#endif
    UNIT_TEST(find_last_not_of);
    UNIT_TEST_SUITE_END();
};

UNIT_TEST_SUITE_REGISTRATION(TStringStdTest);

class TWideStringStdTest: public TTestBase, private TStringStdTestImpl<TUtf16String, TTestData<wchar16>> {
public:
    UNIT_TEST_SUITE(TWideStringStdTest);
    UNIT_TEST(Constructor);
    UNIT_TEST(reserve);
    UNIT_TEST(short_string);
    UNIT_TEST(erase);
    UNIT_TEST(data);
    UNIT_TEST(c_str);
    UNIT_TEST(null_char_of_empty);
    UNIT_TEST(null_char);
    UNIT_TEST(null_char_assignment_to_subscript_of_empty);
    UNIT_TEST(null_char_assignment_to_subscript_of_nonempty);
#ifndef TSTRING_IS_STD_STRING
    UNIT_TEST(null_char_assignment_to_end_of_empty);
    UNIT_TEST(null_char_assignment_to_end_of_nonempty);
#endif
    UNIT_TEST(insert);
    UNIT_TEST(resize);
    UNIT_TEST(find);
    UNIT_TEST(capacity);
    UNIT_TEST(assign);
    UNIT_TEST(copy);
    UNIT_TEST(cbegin_cend);
    UNIT_TEST(compare);
    UNIT_TEST(find_last_of);
#if 0
        UNIT_TEST(rfind);
        UNIT_TEST(replace);
#endif
    UNIT_TEST(find_last_not_of);
    UNIT_TEST_SUITE_END();
};

UNIT_TEST_SUITE_REGISTRATION(TWideStringStdTest);

Y_UNIT_TEST_SUITE(TStringConversionTest) {
    Y_UNIT_TEST(ConversionToStdStringTest) {
        TString abra = "cadabra";
        std::string stdAbra = abra;
        UNIT_ASSERT_VALUES_EQUAL(stdAbra, "cadabra");
    }

    Y_UNIT_TEST(ConversionToStdStringViewTest) {
        TString abra = "cadabra";
        std::string_view stdAbra = abra;
        UNIT_ASSERT_VALUES_EQUAL(stdAbra, "cadabra");
    }
}

Y_UNIT_TEST_SUITE(HashFunctorTests) {
    Y_UNIT_TEST(TestTransparency) {
        THash<TString> h;
        const char* ptr = "a";
        const TStringBuf strbuf = ptr;
        const TString str = ptr;
        const std::string stdStr = ptr;
        UNIT_ASSERT_VALUES_EQUAL(h(ptr), h(strbuf));
        UNIT_ASSERT_VALUES_EQUAL(h(ptr), h(str));
        UNIT_ASSERT_VALUES_EQUAL(h(ptr), h(stdStr));
    }
}

#if !defined(TSTRING_IS_STD_STRING)
Y_UNIT_TEST_SUITE(StdNonConformant) {
    Y_UNIT_TEST(TestEraseNoThrow) {
        TString x;

        LegacyErase(x, 10);
    }

    Y_UNIT_TEST(TestReplaceNoThrow) {
        TString x;

        LegacyReplace(x, 0, 0, "1");

        UNIT_ASSERT_VALUES_EQUAL(x, "1");

        LegacyReplace(x, 10, 0, "1");

        UNIT_ASSERT_VALUES_EQUAL(x, "1");
    }

    Y_UNIT_TEST(TestNoAlias) {
        TString s = "x";

        s.AppendNoAlias("abc", 3);

        UNIT_ASSERT_VALUES_EQUAL(s, "xabc");
        UNIT_ASSERT_VALUES_EQUAL(TString(s.c_str()), "xabc");
    }
}
#endif

Y_UNIT_TEST_SUITE(Interop) {
    static void Mutate(std::string& s) {
        s += "y";
    }

    static void Mutate(TString& s) {
        Mutate(MutRef(s));
    }

    Y_UNIT_TEST(TestMutate) {
        TString x = "x";

        Mutate(x);

        UNIT_ASSERT_VALUES_EQUAL(x, "xy");
    }

    static std::string TransformStd(const std::string& s) {
        return s + "y";
    }

    static TString Transform(const TString& s) {
        return TransformStd(s);
    }

    Y_UNIT_TEST(TestTransform) {
        UNIT_ASSERT_VALUES_EQUAL(Transform(TString("x")), "xy");
    }

    Y_UNIT_TEST(TestTemp) {
        UNIT_ASSERT_VALUES_EQUAL("x" + ConstRef(TString("y")), "xy");
    }
}