base_test.cpp

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

    cb7.push_back(8);
    cb7.push_back(9);
    it1 = cb7.end();
    it2 = cb7.begin();
    it3 = cb7.begin() + 6;
    cb7.rset_capacity(10);
    BOOST_CHECK(it1.is_valid(&cb7));
    BOOST_CHECK(it2.is_valid(&cb7));
    BOOST_CHECK(it3.is_valid(&cb7));
    cb7.rset_capacity(20);
    BOOST_CHECK(it1.is_valid(&cb7));
    BOOST_CHECK(!it2.is_valid(&cb7));
    BOOST_CHECK(!it3.is_valid(&cb7));
    cb7.push_back(10);
    it1 = cb7.end();
    it2 = cb7.begin();
    it3 = cb7.begin() + 6;
    cb7.rset_capacity(10);
    BOOST_CHECK(it1.is_valid(&cb7));
    BOOST_CHECK(!it2.is_valid(&cb7));
    BOOST_CHECK(!it3.is_valid(&cb7));

    circular_buffer<MyInteger> cb8(10, 1);
    cb8.push_back(2);
    cb8.push_back(3);
    it1 = cb8.end();
    it2 = cb8.begin();
    it3 = cb8.begin() + 6;
    cb8.resize(10);
    BOOST_CHECK(it1.is_valid(&cb8));
    BOOST_CHECK(it2.is_valid(&cb8));
    BOOST_CHECK(it3.is_valid(&cb8));
    cb8.resize(20);
    BOOST_CHECK(it1.is_valid(&cb8));
    BOOST_CHECK(!it2.is_valid(&cb8));
    BOOST_CHECK(!it3.is_valid(&cb8));
    cb8.push_back(4);
    it1 = cb8.end();
    it2 = cb8.begin();
    it3 = cb8.begin() + 6;
    it4 = cb8.begin() + 12;
    cb8.resize(10);
    BOOST_CHECK(it1.is_valid(&cb8));
    BOOST_CHECK(it2.is_valid(&cb8));
    BOOST_CHECK(it3.is_valid(&cb8));
    BOOST_CHECK(!it4.is_valid(&cb8));

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

    circular_buffer<MyInteger> cb9(15, 1);
    it1 = cb9.end();
    it2 = cb9.begin();
    it3 = cb9.begin() + 6;
    it4 = cb9.begin() + 12;
    cb9 = cb8;
    BOOST_CHECK(it1.is_valid(&cb9));
    BOOST_CHECK(!it2.is_valid(&cb9));
    BOOST_CHECK(!it3.is_valid(&cb9));
    BOOST_CHECK(!it4.is_valid(&cb9));

    circular_buffer<MyInteger> cb10(10, 1);
    it1 = cb10.end();
    it2 = cb10.begin();
    it3 = cb10.begin() + 3;
    it4 = cb10.begin() + 7;
    cb10.assign(5, 2);
    BOOST_CHECK(it1.is_valid(&cb10));
    BOOST_CHECK(!it2.is_valid(&cb10));
    BOOST_CHECK(!it3.is_valid(&cb10));
    BOOST_CHECK(!it4.is_valid(&cb10));

    circular_buffer<MyInteger> cb11(10, 1);
    it1 = cb11.end();
    it2 = cb11.begin();
    it3 = cb11.begin() + 3;
    it4 = cb11.begin() + 7;
    cb11.assign(15, 5, 2);
    BOOST_CHECK(it1.is_valid(&cb11));
    BOOST_CHECK(!it2.is_valid(&cb11));
    BOOST_CHECK(!it3.is_valid(&cb11));
    BOOST_CHECK(!it4.is_valid(&cb11));

    circular_buffer<MyInteger> cb12(10, 1);
    it1 = cb12.end();
    it2 = cb12.begin();
    it3 = cb12.begin() + 3;
    it4 = cb12.begin() + 7;
    cb12.assign(cb11.begin(), cb11.end());
    BOOST_CHECK(it1.is_valid(&cb12));
    BOOST_CHECK(!it2.is_valid(&cb12));
    BOOST_CHECK(!it3.is_valid(&cb12));
    BOOST_CHECK(!it4.is_valid(&cb12));

    circular_buffer<MyInteger> cb13(10, 1);
    it1 = cb13.end();
    it2 = cb13.begin();
    it3 = cb13.begin() + 3;
    it4 = cb13.begin() + 7;
    cb13.assign(15, cb11.begin(), cb11.end());
    BOOST_CHECK(it1.is_valid(&cb13));
    BOOST_CHECK(!it2.is_valid(&cb13));
    BOOST_CHECK(!it3.is_valid(&cb13));
    BOOST_CHECK(!it4.is_valid(&cb13));

    circular_buffer<MyInteger> cb14(10);
    cb14.push_back(1);
    cb14.push_back(2);
    cb14.push_back(3);
    cb14.push_back(4);
    cb14.push_back(5);
    cb14.push_back(6);
    cb14.push_back(7);
    it1 = cb14.end();
    it2 = cb14.begin() + 2;
    it3 = cb14.begin() + 1;
    it4 = cb14.begin() + 5;
    cb14.rotate(it2);
    BOOST_CHECK(it1.is_valid(&cb14));
    BOOST_CHECK(it2.is_valid(&cb14));
    BOOST_CHECK(!it3.is_valid(&cb14));
    BOOST_CHECK(it4.is_valid(&cb14));

    circular_buffer<MyInteger> cb15(7);
    cb15.push_back(1);
    cb15.push_back(2);
    cb15.push_back(3);
    cb15.push_back(4);
    cb15.push_back(5);
    cb15.push_back(6);
    cb15.push_back(7);
    cb15.push_back(8);
    cb15.push_back(9);
    it1 = cb15.end();
    it2 = cb15.begin() + 2;
    it3 = cb15.begin() + 1;
    it4 = cb15.begin() + 5;
    cb15.rotate(it3);
    BOOST_CHECK(it1.is_valid(&cb15));
    BOOST_CHECK(it2.is_valid(&cb15));
    BOOST_CHECK(it3.is_valid(&cb15));
    BOOST_CHECK(it4.is_valid(&cb15));

    circular_buffer<MyInteger> cb16(10);
    cb16.push_back(1);
    cb16.push_back(2);
    cb16.push_back(3);
    cb16.push_back(4);
    cb16.push_back(5);
    cb16.push_back(6);
    cb16.push_back(7);
    it1 = cb16.end();
    it2 = cb16.begin() + 6;
    it3 = cb16.begin();
    it4 = cb16.begin() + 5;
    cb16.rotate(it4);
    BOOST_CHECK(it1.is_valid(&cb16));
    BOOST_CHECK(!it2.is_valid(&cb16));
    BOOST_CHECK(it3.is_valid(&cb16));
    BOOST_CHECK(!it4.is_valid(&cb16));

#endif // #if !defined(NDEBUG) && !defined(BOOST_CB_DISABLE_DEBUG)
}

// basic exception safety test (it is useful to use any memory-leak detection tool)
void exception_safety_test() {

#if !defined(BOOST_NO_EXCEPTIONS)

    circular_buffer<MyInteger> cb1(3, 5);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb1.set_capacity(5), std::exception);
    BOOST_CHECK(cb1.capacity() == 3);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb1.rset_capacity(5), std::exception);
    BOOST_CHECK(cb1.capacity() == 3);
    generic_test(cb1);

    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb2(5, 10), std::exception);

    circular_buffer<MyInteger> cb3(5, 10);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb4(cb3), std::exception);

    vector<MyInteger> v(5, MyInteger(10));
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb5(8, v.begin(), v.end()), std::exception);

    circular_buffer<MyInteger> cb6(5, 10);
    circular_buffer<MyInteger> cb7(8, 3);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb7 = cb6, std::exception);
    BOOST_CHECK(cb7.size() == 8);
    BOOST_CHECK(cb7.capacity() == 8);
    BOOST_CHECK(cb7[0] == 3);
    BOOST_CHECK(cb7[7] == 3);
    generic_test(cb7);

    circular_buffer<MyInteger> cb8(5, 10);
    MyInteger::set_exception_trigger(2);
    BOOST_CHECK_THROW(cb8.push_front(1), std::exception);

    circular_buffer<MyInteger> cb9(5);
    cb9.push_back(1);
    cb9.push_back(2);
    cb9.push_back(3);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb9.insert(cb9.begin() + 1, 4), std::exception);

    circular_buffer<MyInteger> cb10(5);
    cb10.push_back(1);
    cb10.push_back(2);
    cb10.push_back(3);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb10.rinsert(cb10.begin() + 1, 4), std::exception);

    circular_buffer<MyInteger> cb11(5);
    cb11.push_back(1);
    cb11.push_back(2);
    MyInteger::set_exception_trigger(2);
    BOOST_CHECK_THROW(cb11.rinsert(cb11.begin(), 1), std::exception);

    circular_buffer<MyInteger> cb12(5, 1);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb12.assign(4, 2), std::exception);

    circular_buffer<MyInteger> cb13(5, 1);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb13.assign(6, 2), std::exception);

    circular_buffer<MyInteger> cb14(5);
    cb14.push_back(1);
    cb14.push_back(2);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb14.insert(cb14.begin(), 10, 3), std::exception);

    circular_buffer<MyInteger> cb15(5);
    cb15.push_back(1);
    cb15.push_back(2);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb15.insert(cb15.end(), 10, 3), std::exception);

    circular_buffer<MyInteger> cb16(5);
    cb16.push_back(1);
    cb16.push_back(2);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb16.rinsert(cb16.begin(), 10, 3), std::exception);

    circular_buffer<MyInteger> cb17(5);
    cb17.push_back(1);
    cb17.push_back(2);
    MyInteger::set_exception_trigger(3);
    BOOST_CHECK_THROW(cb17.rinsert(cb17.end(), 10, 3), std::exception);

    circular_buffer<MyInteger> cb18(5, 0);
    cb18.push_back(1);
    cb18.push_back(2);
    cb18.pop_front();
    MyInteger::set_exception_trigger(4);
    BOOST_CHECK_THROW(cb18.linearize(), std::exception);

    circular_buffer<MyInteger> cb19(5, 0);
    cb19.push_back(1);
    cb19.push_back(2);
    MyInteger::set_exception_trigger(5);
    BOOST_CHECK_THROW(cb19.linearize(), std::exception);

    circular_buffer<MyInteger> cb20(5, 0);
    cb20.push_back(1);
    cb20.push_back(2);
    MyInteger::set_exception_trigger(6);
    BOOST_CHECK_THROW(cb20.linearize(), std::exception);

    circular_buffer<MyInteger> cb21(5);
    cb21.push_back(1);
    cb21.push_back(2);
    cb21.push_back(3);
    MyInteger::set_exception_trigger(2);
    BOOST_CHECK_THROW(cb21.insert(cb21.begin() + 1, 4), std::exception);

    circular_buffer<MyInteger> cb22(5);
    cb22.push_back(1);
    cb22.push_back(2);
    cb22.push_back(3);
    MyInteger::set_exception_trigger(2);
    BOOST_CHECK_THROW(cb22.insert(cb22.end(), 4), std::exception);

    circular_buffer<MyInteger> cb23(5, 0);
    MyInteger::set_exception_trigger(2);
    BOOST_CHECK_THROW(cb23.insert(cb23.begin() + 1, 4), std::exception);

    circular_buffer<MyInteger> cb24(5);
    cb24.push_back(1);
    cb24.push_back(2);
    cb24.push_back(3);
    MyInteger::set_exception_trigger(2);
    BOOST_CHECK_THROW(cb24.rinsert(cb24.begin() + 1, 4), std::exception);

    circular_buffer<MyInteger> cb25(5, 0);
    MyInteger::set_exception_trigger(2);
    BOOST_CHECK_THROW(cb25.rinsert(cb25.begin() + 3, 4), std::exception);

    circular_buffer<MyInteger> cb26(5);
    cb26.push_back(1);
    cb26.push_back(2);
    MyInteger::set_exception_trigger(5);
    BOOST_CHECK_THROW(cb26.insert(cb26.begin(), 10, 3), std::exception);

    circular_buffer<MyInteger> cb27(5);
    cb27.push_back(1);
    cb27.push_back(2);
    MyInteger::set_exception_trigger(5);
    BOOST_CHECK_THROW(cb27.insert(cb27.end(), 10, 3), std::exception);

    circular_buffer<MyInteger> cb28(5);
    cb28.push_back(1);
    cb28.push_back(2);
    MyInteger::set_exception_trigger(5);
    BOOST_CHECK_THROW(cb28.rinsert(cb28.begin(), 10, 3), std::exception);

    circular_buffer<MyInteger> cb29(5);
    cb29.push_back(1);
    cb29.push_back(2);
    MyInteger::set_exception_trigger(5);
    BOOST_CHECK_THROW(cb29.rinsert(cb29.end(), 10, 3), std::exception);

    circular_buffer<MyInteger> cb30(10);
    cb30.push_back(1);
    cb30.push_back(2);
    cb30.push_back(3);
    MyInteger::set_exception_trigger(2);
    BOOST_CHECK_THROW(cb30.rinsert(cb30.begin(), 10, 3), std::exception);

#endif // #if !defined(BOOST_NO_EXCEPTIONS)
}

// test main
test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {

    test_suite* tests = BOOST_TEST_SUITE("Unit tests for the circular_buffer.");
    add_common_tests(tests);

    tests->add(BOOST_TEST_CASE(&iterator_constructor_and_assign_test));
    tests->add(BOOST_TEST_CASE(&iterator_reference_test));
    tests->add(BOOST_TEST_CASE(&iterator_difference_test));
    tests->add(BOOST_TEST_CASE(&iterator_increment_test));
    tests->add(BOOST_TEST_CASE(&iterator_decrement_test));
    tests->add(BOOST_TEST_CASE(&iterator_addition_test));
    tests->add(BOOST_TEST_CASE(&iterator_subtraction_test));
    tests->add(BOOST_TEST_CASE(&iterator_element_access_test));
    tests->add(BOOST_TEST_CASE(&iterator_comparison_test));
    tests->add(BOOST_TEST_CASE(&iterator_invalidation_test));
    tests->add(BOOST_TEST_CASE(&exception_safety_test));

    return tests;
}