Method TestCharRef

util/generic/string_ut.h:1005–1050

#ifndef TSTRING_IS_STD_STRING
    void TestCharRef() {
        const char_type abc[] = {'a', 'b', 'c', 0};
        const char_type bbc[] = {'b', 'b', 'c', 0};
        const char_type cbc[] = {'c', 'b', 'c', 0};

        TStringType s0 = abc;
        TStringType s1 = s0;

        UNIT_ASSERT(!s0.IsDetached());
        UNIT_ASSERT(!s1.IsDetached());

        /* Read access shouldn't detach. */
        UNIT_ASSERT_VALUES_EQUAL(s0[0], (ui8)'a');
        UNIT_ASSERT(!s0.IsDetached());
        UNIT_ASSERT(!s1.IsDetached());

        /* Writing should detach. */
        s1[0] = (ui8)'b';
        TStringType s2 = s0;
        s0[0] = (ui8)'c';

        UNIT_ASSERT_VALUES_EQUAL(s0, cbc);
        UNIT_ASSERT_VALUES_EQUAL(s1, bbc);
        UNIT_ASSERT_VALUES_EQUAL(s2, abc);
        UNIT_ASSERT(s0.IsDetached());
        UNIT_ASSERT(s1.IsDetached());
        UNIT_ASSERT(s2.IsDetached());

        /* Accessing null terminator is OK. Note that writing into it is UB. */
        UNIT_ASSERT_VALUES_EQUAL(s0[3], (ui8)'\0');
        UNIT_ASSERT_VALUES_EQUAL(s1[3], (ui8)'\0');
        UNIT_ASSERT_VALUES_EQUAL(s2[3], (ui8)'\0');

        /* Assignment one char reference to another results in modification of underlying character */
        {
            const char_type dark_eyed[] = {'d', 'a', 'r', 'k', '-', 'e', 'y', 'e', 'd', 0};
            const char_type red_eared[] = {'r', 'e', 'd', '-', 'e', 'a', 'r', 'e', 'd', 0};
            TStringType s0 = dark_eyed;
            TStringType s1 = TStringType::Uninitialized(s0.size());
            for (size_t i = 0; i < s1.size(); ++i) {
                const size_t j = (3u * (i + 1u) ^ 1u) % s0.size();
                s1[i] = s0[j];
            }
            UNIT_ASSERT_VALUES_EQUAL(s1, red_eared);
        }
    }
#endif

    void TestBack() {