view release on metacpan or  search on metacpan

t/string_test.h  view on Meta::CPAN

            REQUIRE_STRM(String(s, 40, 10), mstr("0123456780"));
            REQUIRE(s.use_count() == 1); //string detached
        }

        SECTION("pop_back") {
            auto exp = StdString(LITERAL).substr(0, LITERAL_LEN-1);
            String s(LITERAL);
            s.pop_back();
            REQUIRE_STR(s, exp, 0);
            s = EMPTY;
            CHECK_ALLOCS();
        }
    }

    static void test_iterator () {
        String s(cstr("0123456789", 5));
        String tmp(s);
        get_allocs();

        SECTION("begin + mutations") {
            auto it = s.begin();
            REQUIRE(*it++ == (T)'0');
            REQUIRE(*it++ == (T)'1');
            REQUIRE(*(it += 2) == (T)'4');
            REQUIRE(*(it -= 1) == (T)'3');

            REQUIRE(s.use_count() == 2); // not detached
            *it = (T)'x';
            REQUIRE(s.use_count() == 1); // detached
            REQUIRE_STRM(String(s, 0, 10), mstr("012x456789"));
        }
        SECTION("end") {
            auto it = s.end();
            REQUIRE(*(--it) == (T)'9');
            REQUIRE(*(--it) == (T)'8');
            std::advance(it, -2);
            REQUIRE(*it == (T)'6');
        }

        SECTION("diffence & eq & ne") {
            auto b = s.begin();
            auto e = s.end();
            REQUIRE(b == b);
            REQUIRE(e == e);
            REQUIRE(b != e);
            REQUIRE(size_t(e - b) == s.length());
        }

        SECTION("ordening relations") {
            auto b = s.begin();
            auto e = s.end();
            REQUIRE(b >= b);
            REQUIRE(!(b > b));
            REQUIRE(e > b);
            REQUIRE(b < e);
            REQUIRE(b <= e);
            REQUIRE(e <= e);
            REQUIRE(!(e < e ));
        }

        SECTION("global -+ operators") {
            auto b = s.begin();
            auto e = s.end();

            REQUIRE(*(b + 1) == (T)'1');
            REQUIRE(*(2 + b) == (T)'2');
            REQUIRE(*(e - 1) == (T)'9');
            REQUIRE(*(2 - e) == (T)'8');
        }

        SECTION("as const iterator") {
            auto b = s.begin();
            auto cb = (const T*)b;
            REQUIRE(*cb++ == (T)'0');
            REQUIRE(*cb++ == (T)'1');
        }

        SECTION("plus and as const iterator") {
            auto b = s.begin() + 2;
            auto cb = (const T*)b;
            REQUIRE(*cb++ == (T)'2');
            REQUIRE(*cb++ == (T)'3');
        }
    }

    static void test_erase () {
        get_allocs();
        SECTION("literal") {
            String s(LITERAL);
            s.erase(11);
            REQUIRE_STR(s, mstr("hello world"), 0);
            CHECK_ALLOCS();
            s.erase(0, 6);
            REQUIRE_STR(s, mstr("world"), 0);
            CHECK_ALLOCS();
            s.erase(1, 3);
            REQUIRE_STR(s, mstr("wd"), MAX_SSO_CHARS);
            CHECK_ALLOCS();
        }
        if (CHAR_SIZE == 1) {
            SECTION("sso") {
                String s(cstr("motherfuck"));
                s.erase(8);
                REQUIRE_STR(s, mstr("motherfu"), MAX_SSO_CHARS);
                s.erase(0, 2);
                REQUIRE_STR(s, mstr("therfu"), MAX_SSO_CHARS-2);
                s.erase(1, 2);
                REQUIRE_STR(s, mstr("trfu"), MAX_SSO_CHARS-4);
                s = EMPTY;
                CHECK_ALLOCS();
            }
        }
        SECTION("internal") {
            auto exp = mstr("0123456789", 7);
            String s(exp.c_str());
            get_allocs();
            s.erase(65);
            REQUIRE_STR(s, mstr("01234567890123456789012345678901234567890123456789012345678901234"), 70);
            s.erase(0, 5);
            REQUIRE_STR(s, mstr("567890123456789012345678901234567890123456789012345678901234"), 65);
            s.erase(5, 5);