base_test.cpp

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

// Test of the base circular buffer container.

// Copyright (c) 2003-2008 Jan Gaspar

// Use, modification, and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#include "test.hpp"

#define CB_CONTAINER circular_buffer

#include "common.ipp"

void iterator_constructor_and_assign_test() {

    circular_buffer<MyInteger> cb(4, 3);
    circular_buffer<MyInteger>::iterator it = cb.begin();
    circular_buffer<MyInteger>::iterator itCopy;
    itCopy = it;
    it = it;
    circular_buffer<MyInteger>::const_iterator cit;
    cit = it;
    circular_buffer<MyInteger>::const_iterator end1 = cb.end();
    circular_buffer<MyInteger>::const_iterator end2 = end1;

    BOOST_CHECK(itCopy == it);
    BOOST_CHECK(cit == it);
    BOOST_CHECK(end1 == end2);
    BOOST_CHECK(it != end1);
    BOOST_CHECK(cit != end2);
}

void iterator_reference_test() {

    circular_buffer<Dummy> cb(3, Dummy());
    circular_buffer<Dummy>::iterator it = cb.begin();
    circular_buffer<Dummy>::const_iterator cit = cb.begin() + 1;

    BOOST_CHECK((*it).m_n == Dummy::eVar);
    BOOST_CHECK((*it).fnc() == Dummy::eFnc);
    BOOST_CHECK((*cit).const_fnc() == Dummy::eConst);
    BOOST_CHECK((*it).virtual_fnc() == Dummy::eVirtual);
    BOOST_CHECK(it->m_n == Dummy::eVar);
    BOOST_CHECK(it->fnc() == Dummy::eFnc);
    BOOST_CHECK(cit->const_fnc() == Dummy::eConst);
    BOOST_CHECK(it->virtual_fnc() == Dummy::eVirtual);
}

void iterator_difference_test() {

    circular_buffer<MyInteger> cb(5, 1);
    cb.push_back(2);
    circular_buffer<MyInteger>::iterator it1 = cb.begin() + 2;
    circular_buffer<MyInteger>::iterator it2 = cb.begin() + 3;
    circular_buffer<MyInteger>::const_iterator begin = cb.begin();
    circular_buffer<MyInteger>::iterator end = cb.end();

    BOOST_CHECK(begin - begin == 0);
    BOOST_CHECK(end - cb.begin() == 5);
    BOOST_CHECK(end - end == 0);
    BOOST_CHECK(begin - cb.end() == -5);
    BOOST_CHECK(it1 - cb.begin() == 2);
    BOOST_CHECK(it1 - begin == 2);
    BOOST_CHECK(end - it1 == 3);
    BOOST_CHECK(it2 - it1 == 1);
    BOOST_CHECK(it1 - it2 == -1);
    BOOST_CHECK(it2 - it2 == 0);
}

void iterator_increment_test() {

    circular_buffer<MyInteger> cb(10, 1);
    cb.push_back(2);
    circular_buffer<MyInteger>::iterator it1 = cb.begin();
    circular_buffer<MyInteger>::iterator it2 = cb.begin() + 5;
    circular_buffer<MyInteger>::iterator it3 = cb.begin() + 9;
    it1++;
    it2++;
    ++it3;

    BOOST_CHECK(it1 == cb.begin() + 1);
    BOOST_CHECK(it2 == cb.begin() + 6);
    BOOST_CHECK(it3 == cb.end());
}

void iterator_decrement_test() {

    circular_buffer<MyInteger> cb(10, 1);
    cb.push_back(2);
    circular_buffer<MyInteger>::iterator it1= cb.end();
    circular_buffer<MyInteger>::iterator it2= cb.end() - 5;
    circular_buffer<MyInteger>::iterator it3= cb.end() - 9;
    --it1;
    it2--;
    --it3;

    BOOST_CHECK(it1 == cb.end() - 1);
    BOOST_CHECK(it2 == cb.end() - 6);
    BOOST_CHECK(it3 == cb.begin());
}

void iterator_addition_test() {

    circular_buffer<MyInteger> cb(10, 1);
    cb.push_back(2);
    cb.push_back(2);
    circular_buffer<MyInteger>::iterator it1 = cb.begin() + 2;
    circular_buffer<MyInteger>::iterator it2 = cb.end();
    circular_buffer<MyInteger>::iterator it3 = cb.begin() + 5;
    circular_buffer<MyInteger>::iterator it4 = cb.begin() + 9;
    it1 += 3;
    it2 += 0;
    it3 += 5;
    it4 += -2;

    BOOST_CHECK(it1 == 5 + cb.begin());
    BOOST_CHECK(it2 == cb.end());
    BOOST_CHECK(it3 == cb.end());
    BOOST_CHECK(it4 + 3 == cb.end());
    BOOST_CHECK((-3) + it4 == cb.begin() + 4);
    BOOST_CHECK(cb.begin() + 0 == cb.begin());
}

void iterator_subtraction_test() {

    circular_buffer<MyInteger> cb(10, 1);
    cb.push_back(2);
    cb.push_back(2);
    cb.push_back(2);
    circular_buffer<MyInteger>::iterator it1 = cb.begin();
    circular_buffer<MyInteger>::iterator it2 = cb.end();
    circular_buffer<MyInteger>::iterator it3 = cb.end() - 5;
    circular_buffer<MyInteger>::iterator it4 = cb.begin() + 7;
    it1 -= -2;
    it2 -= 0;
    it3 -= 5;

    BOOST_CHECK(it1 == cb.begin() + 2);
    BOOST_CHECK(it2 == cb.end());
    BOOST_CHECK(it3 == cb.begin());
    BOOST_CHECK(it4 - 7 == cb.begin());
    BOOST_CHECK(it4 - (-3) == cb.end());
    BOOST_CHECK(cb.begin() - 0 == cb.begin());
}

void iterator_element_access_test() {

    circular_buffer<MyInteger> cb(10);
    cb.push_back(1);
    cb.push_back(2);
    cb.push_back(3);
    cb.push_back(4);
    cb.push_back(5);
    cb.push_back(6);
    circular_buffer<MyInteger>::iterator it = cb.begin() + 1;

    BOOST_CHECK(it[0] == 2);
    BOOST_CHECK(it[-1] == 1);
    BOOST_CHECK(it[2] == 4);
}

void iterator_comparison_test() {

    circular_buffer<MyInteger> cb(5, 1);
    cb.push_back(2);
    circular_buffer<MyInteger>::iterator it = cb.begin() + 2;
    circular_buffer<MyInteger>::const_iterator begin = cb.begin();
    circular_buffer<MyInteger>::iterator end = cb.end();

    BOOST_CHECK(begin == begin);
    BOOST_CHECK(end > cb.begin());
    BOOST_CHECK(begin < end);
    BOOST_CHECK(end > begin);
    BOOST_CHECK(end == end);
    BOOST_CHECK(begin < cb.end());
    BOOST_CHECK(!(begin + 1 > cb.end()));
    BOOST_CHECK(it > cb.begin());
    BOOST_CHECK(end > it);
    BOOST_CHECK(begin >= begin);
    BOOST_CHECK(end >= cb.begin());
    BOOST_CHECK(end <= end);
    BOOST_CHECK(begin <= cb.end());
    BOOST_CHECK(it >= cb.begin());
    BOOST_CHECK(end >= it);
    BOOST_CHECK(!(begin + 4 < begin + 4));
    BOOST_CHECK(begin + 4 < begin + 5);
    BOOST_CHECK(!(begin + 5 < begin + 4));
    BOOST_CHECK(it < end - 1);
    BOOST_CHECK(!(end - 1 < it));
}

void iterator_invalidation_test() {

#if !defined(NDEBUG) && !defined(BOOST_CB_DISABLE_DEBUG)

    circular_buffer<MyInteger>::iterator it1;
    circular_buffer<MyInteger>::const_iterator it2;
    circular_buffer<MyInteger>::iterator it3;
    circular_buffer<MyInteger>::const_iterator it4;
    circular_buffer<MyInteger>::const_iterator it5;
    circular_buffer<MyInteger>::const_iterator it6;

    BOOST_CHECK(it1.is_valid(0));
    BOOST_CHECK(it2.is_valid(0));
    BOOST_CHECK(it3.is_valid(0));
    BOOST_CHECK(it4.is_valid(0));
    BOOST_CHECK(it5.is_valid(0));
    BOOST_CHECK(it6.is_valid(0));

    {
        circular_buffer<MyInteger> cb(5, 0);
        const circular_buffer<MyInteger> ccb(5, 0);

        it1 = cb.begin();
        it2 = ccb.begin();
        it3 = cb.end();
        it4 = it1;
        it5 = it2;
        it6 = it1;

        BOOST_CHECK(it1.is_valid(&cb));
        BOOST_CHECK(it2.is_valid(&ccb));
        BOOST_CHECK(it3.is_valid(&cb));
        BOOST_CHECK(it4.is_valid(&cb));
        BOOST_CHECK(it5.is_valid(&ccb));
        BOOST_CHECK(it6.is_valid(&cb));
    }

    BOOST_CHECK(it1.is_valid(0));
    BOOST_CHECK(it2.is_valid(0));
    BOOST_CHECK(it3.is_valid(0));
    BOOST_CHECK(it4.is_valid(0));
    BOOST_CHECK(it5.is_valid(0));
    BOOST_CHECK(it6.is_valid(0));

    circular_buffer<MyInteger> cb(10, 0);
    it1 = cb.end();
    cb.clear();
    BOOST_CHECK(it1.is_valid(&cb));
    cb.push_back(1);
    cb.push_back(2);
    cb.push_back(3);
    int i = 0;
    for (it2 = cb.begin(); it2 != it1; it2++, i++);
    BOOST_CHECK(i == 3);

    circular_buffer<MyInteger> cb1(10, 0);
    circular_buffer<MyInteger> cb2(20, 0);
    it1 = cb1.end();
    it2 = cb2.begin();
    BOOST_CHECK(it1.is_valid(&cb1));
    BOOST_CHECK(it2.is_valid(&cb2));

    cb1.swap(cb2);
    BOOST_CHECK(!it1.is_valid(&cb1));
    BOOST_CHECK(!it2.is_valid(&cb2));

    it1 = cb1.begin() + 3;
    it2 = cb1.begin();
    cb1.push_back(1);
    BOOST_CHECK(it1.is_valid(&cb1));
    BOOST_CHECK(!it2.is_valid(&cb1));
    BOOST_CHECK(*it2.m_it == 1);

    circular_buffer<MyInteger> cb3(5);
    cb3.push_back(1);
    cb3.push_back(2);
    cb3.push_back(3);
    cb3.push_back(4);
    cb3.push_back(5);
    it1 = cb3.begin() + 2;
    it2 = cb3.begin();
    cb3.insert(cb3.begin() + 3, 6);
    BOOST_CHECK(it1.is_valid(&cb3));
    BOOST_CHECK(!it2.is_valid(&cb3));
    BOOST_CHECK(*it2.m_it == 5);

    it1 = cb3.begin() + 3;
    it2 = cb3.end() - 1;
    cb3.push_front(7);
    BOOST_CHECK(it1.is_valid(&cb3));
    BOOST_CHECK(!it2.is_valid(&cb3));
    BOOST_CHECK(*it2.m_it == 7);

    circular_buffer<MyInteger> cb4(5);
    cb4.push_back(1);
    cb4.push_back(2);
    cb4.push_back(3);
    cb4.push_back(4);
    cb4.push_back(5);
    it1 = cb4.begin() + 3;
    it2 = cb4.begin();
    cb4.rinsert(cb4.begin() + 2, 6);
    BOOST_CHECK(it1.is_valid(&cb4));
    BOOST_CHECK(!it2.is_valid(&cb4));
    BOOST_CHECK(*it2.m_it == 2);

    it1 = cb1.begin() + 5;
    it2 = cb1.end() - 1;
    cb1.pop_back();
    BOOST_CHECK(it1.is_valid(&cb1));
    BOOST_CHECK(!it2.is_valid(&cb1));

    it1 = cb1.begin() + 5;
    it2 = cb1.begin();
    cb1.pop_front();
    BOOST_CHECK(it1.is_valid(&cb1));
    BOOST_CHECK(!it2.is_valid(&cb1));

    circular_buffer<MyInteger> cb5(20, 0);
    it1 = cb5.begin() + 5;
    it2 = it3 = cb5.begin() + 15;
    cb5.erase(cb5.begin() + 10);
    BOOST_CHECK(it1.is_valid(&cb5));
    BOOST_CHECK(!it2.is_valid(&cb5));
    BOOST_CHECK(!it3.is_valid(&cb5));

    it1 = cb5.begin() + 1;
    it2 = it3 = cb5.begin() + 8;
    cb5.erase(cb5.begin() + 3, cb5.begin() + 7);
    BOOST_CHECK(it1.is_valid(&cb5));
    BOOST_CHECK(!it2.is_valid(&cb5));
    BOOST_CHECK(!it3.is_valid(&cb5));

    circular_buffer<MyInteger> cb6(20, 0);
    it4 = it1 = cb6.begin() + 5;
    it2 = cb6.begin() + 15;
    cb6.rerase(cb6.begin() + 10);
    BOOST_CHECK(!it1.is_valid(&cb6));
    BOOST_CHECK(!it4.is_valid(&cb6));
    BOOST_CHECK(it2.is_valid(&cb6));

    it4 = it1 = cb6.begin() + 1;
    it2 = cb6.begin() + 8;
    cb6.rerase(cb6.begin() + 3, cb6.begin() + 7);
    BOOST_CHECK(!it1.is_valid(&cb6));
    BOOST_CHECK(!it4.is_valid(&cb6));
    BOOST_CHECK(it2.is_valid(&cb6));

    circular_buffer<MyInteger> cb7(10, 1);
    cb7.push_back(2);
    cb7.push_back(3);
    cb7.push_back(4);
    it1 = cb7.end();
    it2 = cb7.begin();
    it3 = cb7.begin() + 6;
    cb7.linearize();
    BOOST_CHECK(it1.is_valid(&cb7));
    BOOST_CHECK(!it2.is_valid(&cb7));
    BOOST_CHECK(!it3.is_valid(&cb7));
    it1 = cb7.end();
    it2 = cb7.begin();
    it3 = cb7.begin() + 6;
    cb7.linearize();
    BOOST_CHECK(it1.is_valid(&cb7));
    BOOST_CHECK(it2.is_valid(&cb7));
    BOOST_CHECK(it3.is_valid(&cb7));

    cb7.push_back(5);
    cb7.push_back(6);
    it1 = cb7.end();
    it2 = cb7.begin();
    it3 = cb7.begin() + 6;
    cb7.set_capacity(10);
    BOOST_CHECK(it1.is_valid(&cb7));
    BOOST_CHECK(it2.is_valid(&cb7));
    BOOST_CHECK(it3.is_valid(&cb7));
    cb7.set_capacity(20);
    BOOST_CHECK(it1.is_valid(&cb7));
    BOOST_CHECK(!it2.is_valid(&cb7));
    BOOST_CHECK(!it3.is_valid(&cb7));
    cb7.push_back(7);
    it1 = cb7.end();
    it2 = cb7.begin();
    it3 = cb7.begin() + 6;
    cb7.set_capacity(10);
    BOOST_CHECK(it1.is_valid(&cb7));
    BOOST_CHECK(!it2.is_valid(&cb7));
    BOOST_CHECK(!it3.is_valid(&cb7));