boostorg/circular_buffer
1
0
Fork 0
mirror of https://github.com/boostorg/circular_buffer.git synced 2026-07-21 13:03:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Switch to lightweight_test for unit tests and switch to non-deprecated timer

Browse Source
This commit is contained in:
Glen Fernandes
2019-04-23 17:07:46 -04:00
parent 03a5c8494e
commit 3d3b5bffd4
11 changed files with 1492 additions and 1503 deletions
Download Patch File Download Diff File Expand all files Collapse all files
appveyor.yml
+4 -4
View File
@@ -12,13 +12,13 @@ branches:
environment:
matrix:
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-9.0
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-10.0
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-11.0
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-12.0
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-14.0
example/bounded_buffer_comparison.cpp
+2 -2
View File
@@ -11,8 +11,8 @@
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/timer/timer.hpp>
#include <boost/call_traits.hpp>
#include <boost/progress.hpp>
#include <boost/bind.hpp>
#include <deque>
#include <list>
@@ -229,7 +229,7 @@ template<class Buffer>
void fifo_test(Buffer* buffer) {
// Start of measurement
boost::progress_timer progress;
boost::timer::auto_cpu_timer progress;
// Initialize the buffer with some values before launching producer and consumer threads.
for (unsigned long i = QUEUE_SIZE / 2L; i > 0; --i) {
example/circular_buffer_bound_example.cpp
+1
View File
@@ -19,6 +19,7 @@ as an underlying container of the bounded buffer.
#include <boost/bind.hpp>
#include <boost/timer/timer.hpp> // for auto_cpu_timer
#include <iostream>
template <class T>
class bounded_buffer
example/jamfile.v2
+1 -1
View File
@@ -35,7 +35,7 @@ project
<toolset>msvc:<cxxflags>/wd4305
;
run bounded_buffer_comparison.cpp ;
run bounded_buffer_comparison.cpp ../../timer/build//boost_timer ;
run circular_buffer_iter_example.cpp ;
run circular_buffer_sum_example.cpp ;
run circular_buffer_bound_example.cpp ../../thread/build//boost_thread ../../timer/build//boost_timer ;
test/base_test.cpp
+282 -285
View File
@@ -25,11 +25,11 @@ void iterator_constructor_and_assign_test() {
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);
BOOST_TEST(itCopy == it);
BOOST_TEST(cit == it);
BOOST_TEST(end1 == end2);
BOOST_TEST(it != end1);
BOOST_TEST(cit != end2);
}
void iterator_reference_test() {
@@ -38,14 +38,14 @@ void iterator_reference_test() {
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);
BOOST_TEST((*it).m_n == Dummy::eVar);
BOOST_TEST((*it).fnc() == Dummy::eFnc);
BOOST_TEST((*cit).const_fnc() == Dummy::eConst);
BOOST_TEST((*it).virtual_fnc() == Dummy::eVirtual);
BOOST_TEST(it->m_n == Dummy::eVar);
BOOST_TEST(it->fnc() == Dummy::eFnc);
BOOST_TEST(cit->const_fnc() == Dummy::eConst);
BOOST_TEST(it->virtual_fnc() == Dummy::eVirtual);
}
void iterator_difference_test() {
@@ -57,16 +57,16 @@ void iterator_difference_test() {
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);
BOOST_TEST(begin - begin == 0);
BOOST_TEST(end - cb.begin() == 5);
BOOST_TEST(end - end == 0);
BOOST_TEST(begin - cb.end() == -5);
BOOST_TEST(it1 - cb.begin() == 2);
BOOST_TEST(it1 - begin == 2);
BOOST_TEST(end - it1 == 3);
BOOST_TEST(it2 - it1 == 1);
BOOST_TEST(it1 - it2 == -1);
BOOST_TEST(it2 - it2 == 0);
}
void iterator_increment_test() {
@@ -80,9 +80,9 @@ void iterator_increment_test() {
it2++;
++it3;
BOOST_CHECK(it1 == cb.begin() + 1);
BOOST_CHECK(it2 == cb.begin() + 6);
BOOST_CHECK(it3 == cb.end());
BOOST_TEST(it1 == cb.begin() + 1);
BOOST_TEST(it2 == cb.begin() + 6);
BOOST_TEST(it3 == cb.end());
}
void iterator_decrement_test() {
@@ -96,9 +96,9 @@ void iterator_decrement_test() {
it2--;
--it3;
BOOST_CHECK(it1 == cb.end() - 1);
BOOST_CHECK(it2 == cb.end() - 6);
BOOST_CHECK(it3 == cb.begin());
BOOST_TEST(it1 == cb.end() - 1);
BOOST_TEST(it2 == cb.end() - 6);
BOOST_TEST(it3 == cb.begin());
}
void iterator_addition_test() {
@@ -115,12 +115,12 @@ void iterator_addition_test() {
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());
BOOST_TEST(it1 == 5 + cb.begin());
BOOST_TEST(it2 == cb.end());
BOOST_TEST(it3 == cb.end());
BOOST_TEST(it4 + 3 == cb.end());
BOOST_TEST((-3) + it4 == cb.begin() + 4);
BOOST_TEST(cb.begin() + 0 == cb.begin());
}
void iterator_subtraction_test() {
@@ -137,12 +137,12 @@ void iterator_subtraction_test() {
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());
BOOST_TEST(it1 == cb.begin() + 2);
BOOST_TEST(it2 == cb.end());
BOOST_TEST(it3 == cb.begin());
BOOST_TEST(it4 - 7 == cb.begin());
BOOST_TEST(it4 - (-3) == cb.end());
BOOST_TEST(cb.begin() - 0 == cb.begin());
}
void iterator_element_access_test() {
@@ -156,9 +156,9 @@ void iterator_element_access_test() {
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);
BOOST_TEST(it[0] == 2);
BOOST_TEST(it[-1] == 1);
BOOST_TEST(it[2] == 4);
}
void iterator_comparison_test() {
@@ -169,26 +169,26 @@ void iterator_comparison_test() {
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));
BOOST_TEST(begin == begin);
BOOST_TEST(end > cb.begin());
BOOST_TEST(begin < end);
BOOST_TEST(end > begin);
BOOST_TEST(end == end);
BOOST_TEST(begin < cb.end());
BOOST_TEST(!(begin + 1 > cb.end()));
BOOST_TEST(it > cb.begin());
BOOST_TEST(end > it);
BOOST_TEST(begin >= begin);
BOOST_TEST(end >= cb.begin());
BOOST_TEST(end <= end);
BOOST_TEST(begin <= cb.end());
BOOST_TEST(it >= cb.begin());
BOOST_TEST(end >= it);
BOOST_TEST(!(begin + 4 < begin + 4));
BOOST_TEST(begin + 4 < begin + 5);
BOOST_TEST(!(begin + 5 < begin + 4));
BOOST_TEST(it < end - 1);
BOOST_TEST(!(end - 1 < it));
}
void iterator_invalidation_test() {
@@ -202,12 +202,12 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(0));
BOOST_TEST(it2.is_valid(0));
BOOST_TEST(it3.is_valid(0));
BOOST_TEST(it4.is_valid(0));
BOOST_TEST(it5.is_valid(0));
BOOST_TEST(it6.is_valid(0));
{
circular_buffer<MyInteger> cb(5, 0);
@@ -220,49 +220,49 @@ void iterator_invalidation_test() {
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_TEST(it1.is_valid(&cb));
BOOST_TEST(it2.is_valid(&ccb));
BOOST_TEST(it3.is_valid(&cb));
BOOST_TEST(it4.is_valid(&cb));
BOOST_TEST(it5.is_valid(&ccb));
BOOST_TEST(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));
BOOST_TEST(it1.is_valid(0));
BOOST_TEST(it2.is_valid(0));
BOOST_TEST(it3.is_valid(0));
BOOST_TEST(it4.is_valid(0));
BOOST_TEST(it5.is_valid(0));
BOOST_TEST(it6.is_valid(0));
circular_buffer<MyInteger> cb(10, 0);
it1 = cb.end();
cb.clear();
BOOST_CHECK(it1.is_valid(&cb));
BOOST_TEST(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);
BOOST_TEST(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));
BOOST_TEST(it1.is_valid(&cb1));
BOOST_TEST(it2.is_valid(&cb2));
cb1.swap(cb2);
BOOST_CHECK(!it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb2));
BOOST_TEST(!it1.is_valid(&cb1));
BOOST_TEST(!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);
BOOST_TEST(it1.is_valid(&cb1));
BOOST_TEST(!it2.is_valid(&cb1));
BOOST_TEST(*it2.m_it == 1);
circular_buffer<MyInteger> cb3(5);
cb3.push_back(1);
@@ -273,16 +273,16 @@ void iterator_invalidation_test() {
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);
BOOST_TEST(it1.is_valid(&cb3));
BOOST_TEST(!it2.is_valid(&cb3));
BOOST_TEST(*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);
BOOST_TEST(it1.is_valid(&cb3));
BOOST_TEST(!it2.is_valid(&cb3));
BOOST_TEST(*it2.m_it == 7);
circular_buffer<MyInteger> cb4(5);
cb4.push_back(1);
@@ -293,51 +293,51 @@ void iterator_invalidation_test() {
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);
BOOST_TEST(it1.is_valid(&cb4));
BOOST_TEST(!it2.is_valid(&cb4));
BOOST_TEST(*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));
BOOST_TEST(it1.is_valid(&cb1));
BOOST_TEST(!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));
BOOST_TEST(it1.is_valid(&cb1));
BOOST_TEST(!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));
BOOST_TEST(it1.is_valid(&cb5));
BOOST_TEST(!it2.is_valid(&cb5));
BOOST_TEST(!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));
BOOST_TEST(it1.is_valid(&cb5));
BOOST_TEST(!it2.is_valid(&cb5));
BOOST_TEST(!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));
BOOST_TEST(!it1.is_valid(&cb6));
BOOST_TEST(!it4.is_valid(&cb6));
BOOST_TEST(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));
BOOST_TEST(!it1.is_valid(&cb6));
BOOST_TEST(!it4.is_valid(&cb6));
BOOST_TEST(it2.is_valid(&cb6));
circular_buffer<MyInteger> cb7(10, 1);
cb7.push_back(2);
@@ -347,16 +347,16 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb7));
BOOST_TEST(!it2.is_valid(&cb7));
BOOST_TEST(!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));
BOOST_TEST(it1.is_valid(&cb7));
BOOST_TEST(it2.is_valid(&cb7));
BOOST_TEST(it3.is_valid(&cb7));
cb7.push_back(5);
cb7.push_back(6);
@@ -364,21 +364,21 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb7));
BOOST_TEST(it2.is_valid(&cb7));
BOOST_TEST(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));
BOOST_TEST(it1.is_valid(&cb7));
BOOST_TEST(!it2.is_valid(&cb7));
BOOST_TEST(!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));
BOOST_TEST(it1.is_valid(&cb7));
BOOST_TEST(!it2.is_valid(&cb7));
BOOST_TEST(!it3.is_valid(&cb7));
cb7.push_back(8);
cb7.push_back(9);
@@ -386,21 +386,21 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb7));
BOOST_TEST(it2.is_valid(&cb7));
BOOST_TEST(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));
BOOST_TEST(it1.is_valid(&cb7));
BOOST_TEST(!it2.is_valid(&cb7));
BOOST_TEST(!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));
BOOST_TEST(it1.is_valid(&cb7));
BOOST_TEST(!it2.is_valid(&cb7));
BOOST_TEST(!it3.is_valid(&cb7));
circular_buffer<MyInteger> cb8(10, 1);
cb8.push_back(2);
@@ -409,23 +409,23 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb8));
BOOST_TEST(it2.is_valid(&cb8));
BOOST_TEST(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));
BOOST_TEST(it1.is_valid(&cb8));
BOOST_TEST(!it2.is_valid(&cb8));
BOOST_TEST(!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));
BOOST_TEST(it1.is_valid(&cb8));
BOOST_TEST(it2.is_valid(&cb8));
BOOST_TEST(it3.is_valid(&cb8));
BOOST_TEST(!it4.is_valid(&cb8));
cb8.set_capacity(10);
cb8.push_back(5);
@@ -434,23 +434,23 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb8));
BOOST_TEST(it2.is_valid(&cb8));
BOOST_TEST(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));
BOOST_TEST(it1.is_valid(&cb8));
BOOST_TEST(!it2.is_valid(&cb8));
BOOST_TEST(!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));
BOOST_TEST(it1.is_valid(&cb8));
BOOST_TEST(!it2.is_valid(&cb8));
BOOST_TEST(!it3.is_valid(&cb8));
BOOST_TEST(it4.is_valid(&cb8));
circular_buffer<MyInteger> cb9(15, 1);
it1 = cb9.end();
@@ -458,10 +458,10 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb9));
BOOST_TEST(!it2.is_valid(&cb9));
BOOST_TEST(!it3.is_valid(&cb9));
BOOST_TEST(!it4.is_valid(&cb9));
circular_buffer<MyInteger> cb10(10, 1);
it1 = cb10.end();
@@ -469,10 +469,10 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb10));
BOOST_TEST(!it2.is_valid(&cb10));
BOOST_TEST(!it3.is_valid(&cb10));
BOOST_TEST(!it4.is_valid(&cb10));
circular_buffer<MyInteger> cb11(10, 1);
it1 = cb11.end();
@@ -480,10 +480,10 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb11));
BOOST_TEST(!it2.is_valid(&cb11));
BOOST_TEST(!it3.is_valid(&cb11));
BOOST_TEST(!it4.is_valid(&cb11));
circular_buffer<MyInteger> cb12(10, 1);
it1 = cb12.end();
@@ -491,10 +491,10 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb12));
BOOST_TEST(!it2.is_valid(&cb12));
BOOST_TEST(!it3.is_valid(&cb12));
BOOST_TEST(!it4.is_valid(&cb12));
circular_buffer<MyInteger> cb13(10, 1);
it1 = cb13.end();
@@ -502,10 +502,10 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb13));
BOOST_TEST(!it2.is_valid(&cb13));
BOOST_TEST(!it3.is_valid(&cb13));
BOOST_TEST(!it4.is_valid(&cb13));
circular_buffer<MyInteger> cb14(10);
cb14.push_back(1);
@@ -520,10 +520,10 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb14));
BOOST_TEST(it2.is_valid(&cb14));
BOOST_TEST(!it3.is_valid(&cb14));
BOOST_TEST(it4.is_valid(&cb14));
circular_buffer<MyInteger> cb15(7);
cb15.push_back(1);
@@ -540,10 +540,10 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb15));
BOOST_TEST(it2.is_valid(&cb15));
BOOST_TEST(it3.is_valid(&cb15));
BOOST_TEST(it4.is_valid(&cb15));
circular_buffer<MyInteger> cb16(10);
cb16.push_back(1);
@@ -558,10 +558,10 @@ void iterator_invalidation_test() {
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));
BOOST_TEST(it1.is_valid(&cb16));
BOOST_TEST(!it2.is_valid(&cb16));
BOOST_TEST(it3.is_valid(&cb16));
BOOST_TEST(!it4.is_valid(&cb16));
#endif // #if BOOST_CB_ENABLE_DEBUG
}
@@ -573,168 +573,168 @@ void exception_safety_test() {
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);
BOOST_TEST_THROWS(cb1.set_capacity(5), std::exception);
BOOST_TEST(cb1.capacity() == 3);
MyInteger::set_exception_trigger(3);
BOOST_CHECK_THROW(cb1.rset_capacity(5), std::exception);
BOOST_CHECK(cb1.capacity() == 3);
BOOST_TEST_THROWS(cb1.rset_capacity(5), std::exception);
BOOST_TEST(cb1.capacity() == 3);
generic_test(cb1);
MyInteger::set_exception_trigger(3);
BOOST_CHECK_THROW(circular_buffer<MyInteger> cb2(5, 10), std::exception);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(cb7 = cb6, std::exception);
BOOST_TEST(cb7.size() == 8);
BOOST_TEST(cb7.capacity() == 8);
BOOST_TEST(cb7[0] == 3);
BOOST_TEST(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(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);
BOOST_TEST_THROWS(cb30.rinsert(cb30.begin(), 10, 3), std::exception);
#endif // #if !defined(BOOST_NO_EXCEPTIONS)
}
@@ -752,84 +752,84 @@ void move_container_values_resetting_impl() {
cb1.push_back();
cb1.push_back(boost::move(var));
BOOST_CHECK(!cb1.back().is_moved());
BOOST_CHECK(var.is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(!cb1.back().is_moved());
BOOST_TEST(var.is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
cb1.push_front(boost::move(var));
BOOST_CHECK(!cb1.front().is_moved());
BOOST_CHECK(var.is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(!cb1.front().is_moved());
BOOST_TEST(var.is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
cb1.push_back();
BOOST_CHECK(!cb1.back().is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(!cb1.back().is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
cb1.push_front();
BOOST_CHECK(!cb1.front().is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(!cb1.front().is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
cb1.insert(cb1.begin());
// If the circular_buffer is full and the pos points to begin(),
// then the item will not be inserted.
BOOST_CHECK(cb1.front().is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(cb1.front().is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
cb1.insert(cb1.begin(), boost::move(var));
// If the circular_buffer is full and the pos points to begin(),
// then the item will not be inserted.
BOOST_CHECK(cb1.front().is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(cb1.front().is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
cb1.rinsert(cb1.begin());
BOOST_CHECK(!cb1.back().is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(!cb1.back().is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
var.reinit();
cb1.rinsert(cb1.begin(), boost::move(var));
BOOST_CHECK(!cb1.back().is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(!cb1.back().is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
cb1.rinsert(cb1.end());
BOOST_CHECK(cb1.back().is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(cb1.back().is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
var.reinit();
cb1.rinsert(cb1.end(), boost::move(var));
BOOST_CHECK(cb1.back().is_moved());
BOOST_CHECK(cb1.size() == 1);
BOOST_TEST(cb1.back().is_moved());
BOOST_TEST(cb1.size() == 1);
var = boost::move(cb1.back());
BOOST_CHECK(cb1.back().is_moved());
BOOST_TEST(cb1.back().is_moved());
cb1.push_back();
BOOST_CHECK(!cb1[0].is_moved());
BOOST_TEST(!cb1[0].is_moved());
const int val = cb1[0].value();
cb1.linearize();
BOOST_CHECK(!cb1[0].is_moved());
BOOST_CHECK(cb1[0].value() == val);
BOOST_TEST(!cb1[0].is_moved());
BOOST_TEST(cb1[0].value() == val);
cb1.rotate(cb1.begin());
BOOST_CHECK(!cb1[0].is_moved());
BOOST_CHECK(cb1[0].value() == val);
BOOST_TEST(!cb1[0].is_moved());
BOOST_TEST(cb1[0].value() == val);
}
void move_container_values_resetting_except() {
@@ -841,25 +841,22 @@ void move_container_values_resetting_noexcept() {
}
// 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));
tests->add(BOOST_TEST_CASE(&move_container_values_except));
tests->add(BOOST_TEST_CASE(&move_container_values_resetting_except));
tests->add(BOOST_TEST_CASE(&move_container_values_resetting_noexcept));
return tests;
int main()
{
run_common_tests();
iterator_constructor_and_assign_test();
iterator_reference_test();
iterator_difference_test();
iterator_increment_test();
iterator_decrement_test();
iterator_addition_test();
iterator_subtraction_test();
iterator_element_access_test();
iterator_comparison_test();
iterator_invalidation_test();
exception_safety_test();
move_container_values_except();
move_container_values_resetting_except();
move_container_values_resetting_noexcept();
return boost::report_errors();
}
test/bounded_buffer_comparison.cpp
+2 -2
View File
@@ -11,8 +11,8 @@
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/thread/thread.hpp>
#include <boost/timer/timer.hpp>
#include <boost/call_traits.hpp>
#include <boost/progress.hpp>
#include <boost/bind.hpp>
#include <deque>
#include <list>
@@ -229,7 +229,7 @@ template<class Buffer>
void fifo_test(Buffer* buffer) {
// Start of measurement
boost::progress_timer progress;
boost::timer::auto_cpu_timer progress;
// Initialize the buffer with some values before launching producer and consumer threads.
for (unsigned long i = QUEUE_SIZE / 2L; i > 0; --i) {
test/common.ipp
+846 -845
View File
File diff suppressed because it is too large Load Diff
test/constant_erase_test.cpp
+57 -60
View File
@@ -25,35 +25,35 @@ void erase_begin_test() {
cb1.erase_begin(2);
BOOST_CHECK(cb1.size() == 3);
BOOST_CHECK(cb1[0] == 4);
BOOST_CHECK(cb1[1] == 5);
BOOST_CHECK(cb1[2] == 6);
BOOST_TEST(cb1.size() == 3);
BOOST_TEST(cb1[0] == 4);
BOOST_TEST(cb1[1] == 5);
BOOST_TEST(cb1[2] == 6);
cb1.erase_begin(3);
BOOST_CHECK(cb1.empty());
BOOST_CHECK(*p == 2);
BOOST_CHECK(*(p + 1) == 3);
BOOST_CHECK(*(p + 2) == 4);
BOOST_TEST(cb1.empty());
BOOST_TEST(*p == 2);
BOOST_TEST(*(p + 1) == 3);
BOOST_TEST(*(p + 2) == 4);
cb1.push_back(10);
cb1.push_back(11);
cb1.push_back(12);
BOOST_CHECK(cb1.size() == 3);
BOOST_CHECK(cb1[0] == 10);
BOOST_CHECK(cb1[1] == 11);
BOOST_CHECK(cb1[2] == 12);
BOOST_TEST(cb1.size() == 3);
BOOST_TEST(cb1[0] == 10);
BOOST_TEST(cb1[1] == 11);
BOOST_TEST(cb1[2] == 12);
circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
BOOST_CHECK(cb2.size() == 5);
BOOST_CHECK(InstanceCounter::count() == 5);
BOOST_TEST(cb2.size() == 5);
BOOST_TEST(InstanceCounter::count() == 5);
cb2.erase_begin(2);
BOOST_CHECK(cb2.size() == 3);
BOOST_CHECK(InstanceCounter::count() == 3);
BOOST_TEST(cb2.size() == 3);
BOOST_TEST(InstanceCounter::count() == 3);
circular_buffer<MyInteger> cb3(5);
cb3.push_back(1);
@@ -64,10 +64,10 @@ void erase_begin_test() {
cb3.push_back(6);
cb3.erase_begin(2);
BOOST_CHECK(cb3.size() == 3);
BOOST_CHECK(cb3[0] == 4);
BOOST_CHECK(cb3[1] == 5);
BOOST_CHECK(cb3[2] == 6);
BOOST_TEST(cb3.size() == 3);
BOOST_TEST(cb3[0] == 4);
BOOST_TEST(cb3[1] == 5);
BOOST_TEST(cb3[2] == 6);
}
void erase_end_test() {
@@ -84,35 +84,35 @@ void erase_end_test() {
cb1.erase_end(2);
BOOST_CHECK(cb1.size() == 3);
BOOST_CHECK(cb1[0] == 2);
BOOST_CHECK(cb1[1] == 3);
BOOST_CHECK(cb1[2] ==4);
BOOST_TEST(cb1.size() == 3);
BOOST_TEST(cb1[0] == 2);
BOOST_TEST(cb1[1] == 3);
BOOST_TEST(cb1[2] ==4);
cb1.erase_end(3);
BOOST_CHECK(cb1.empty());
BOOST_CHECK(*p == 5);
BOOST_CHECK(*(p - 1) == 4);
BOOST_CHECK(*(p - 2) == 3);
BOOST_TEST(cb1.empty());
BOOST_TEST(*p == 5);
BOOST_TEST(*(p - 1) == 4);
BOOST_TEST(*(p - 2) == 3);
cb1.push_back(10);
cb1.push_back(11);
cb1.push_back(12);
BOOST_CHECK(cb1.size() == 3);
BOOST_CHECK(cb1[0] == 10);
BOOST_CHECK(cb1[1] == 11);
BOOST_CHECK(cb1[2] == 12);
BOOST_TEST(cb1.size() == 3);
BOOST_TEST(cb1[0] == 10);
BOOST_TEST(cb1[1] == 11);
BOOST_TEST(cb1[2] == 12);
circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
BOOST_CHECK(cb2.size() == 5);
BOOST_CHECK(InstanceCounter::count() == 5);
BOOST_TEST(cb2.size() == 5);
BOOST_TEST(InstanceCounter::count() == 5);
cb2.erase_end(2);
BOOST_CHECK(cb2.size() == 3);
BOOST_CHECK(InstanceCounter::count() == 3);
BOOST_TEST(cb2.size() == 3);
BOOST_TEST(InstanceCounter::count() == 3);
circular_buffer<MyInteger> cb3(5);
cb3.push_back(1);
@@ -123,10 +123,10 @@ void erase_end_test() {
cb3.push_back(6);
cb3.erase_end(2);
BOOST_CHECK(cb3.size() == 3);
BOOST_CHECK(cb3[0] == 2);
BOOST_CHECK(cb3[1] == 3);
BOOST_CHECK(cb3[2] == 4);
BOOST_TEST(cb3.size() == 3);
BOOST_TEST(cb3[0] == 2);
BOOST_TEST(cb3[1] == 3);
BOOST_TEST(cb3[2] == 4);
}
void clear_test() {
@@ -143,22 +143,22 @@ void clear_test() {
cb1.clear();
BOOST_CHECK(cb1.empty());
BOOST_CHECK(*p == 2);
BOOST_CHECK(*(p + 1) == 3);
BOOST_CHECK(*(p + 2) == 4);
BOOST_CHECK(*(p + 3) == 5);
BOOST_CHECK(*(p - 1) == 6);
BOOST_TEST(cb1.empty());
BOOST_TEST(*p == 2);
BOOST_TEST(*(p + 1) == 3);
BOOST_TEST(*(p + 2) == 4);
BOOST_TEST(*(p + 3) == 5);
BOOST_TEST(*(p - 1) == 6);
circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
BOOST_CHECK(cb2.size() == 5);
BOOST_CHECK(InstanceCounter::count() == 5);
BOOST_TEST(cb2.size() == 5);
BOOST_TEST(InstanceCounter::count() == 5);
cb2.clear();
BOOST_CHECK(cb2.empty());
BOOST_CHECK(InstanceCounter::count() == 0);
BOOST_TEST(cb2.empty());
BOOST_TEST(InstanceCounter::count() == 0);
circular_buffer<MyInteger> cb3(5);
cb3.push_back(1);
@@ -169,17 +169,14 @@ void clear_test() {
cb3.push_back(6);
cb3.clear();
BOOST_CHECK(cb3.empty());
BOOST_TEST(cb3.empty());
}
// test main
test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
test_suite* tests = BOOST_TEST_SUITE("Unit tests for erase_begin/end and clear methods of the circular_buffer.");
tests->add(BOOST_TEST_CASE(&erase_begin_test));
tests->add(BOOST_TEST_CASE(&erase_end_test));
tests->add(BOOST_TEST_CASE(&clear_test));
return tests;
int main()
{
erase_begin_test();
erase_end_test();
clear_test();
return boost::report_errors();
}
test/soft_iterator_invalidation.cpp
+230 -233
View File
@@ -22,11 +22,11 @@ void validity_example_test() {
circular_buffer<int>::iterator it = cb.begin();
BOOST_CHECK(*it == 1);
BOOST_TEST(*it == 1);
cb.push_back(4);
BOOST_CHECK(*it == 4);
BOOST_TEST(*it == 4);
}
void validity_insert_test() {
@@ -46,13 +46,13 @@ void validity_insert_test() {
// memory placement: { 1, 4, 2, 3 }
// circular buffer: { 1, 4, 2, 3 }
BOOST_CHECK(*it1 == 1);
BOOST_CHECK(*it2 == 4);
BOOST_CHECK(*it3 == 2);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 4);
BOOST_CHECK(cb[2] == 2);
BOOST_CHECK(cb[3] == 3);
BOOST_TEST(*it1 == 1);
BOOST_TEST(*it2 == 4);
BOOST_TEST(*it3 == 2);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 4);
BOOST_TEST(cb[2] == 2);
BOOST_TEST(cb[3] == 3);
// it4 -> 3
circular_buffer<int>::iterator it4 = it1 + 3;
@@ -61,14 +61,14 @@ void validity_insert_test() {
// memory placement: { 3, 5, 4, 2 }
// circular buffer: { 5, 4, 2, 3 }
BOOST_CHECK(*it1 == 3);
BOOST_CHECK(*it2 == 5);
BOOST_CHECK(*it3 == 4);
BOOST_CHECK(*it4 == 2);
BOOST_CHECK(cb[0] == 5);
BOOST_CHECK(cb[1] == 4);
BOOST_CHECK(cb[2] == 2);
BOOST_CHECK(cb[3] == 3);
BOOST_TEST(*it1 == 3);
BOOST_TEST(*it2 == 5);
BOOST_TEST(*it3 == 4);
BOOST_TEST(*it4 == 2);
BOOST_TEST(cb[0] == 5);
BOOST_TEST(cb[1] == 4);
BOOST_TEST(cb[2] == 2);
BOOST_TEST(cb[3] == 3);
}
void validity_insert_n_test() {
@@ -89,14 +89,14 @@ void validity_insert_n_test() {
// memory placement: { 1, 4, 4, 2, 3 }
// circular buffer: { 1, 4, 4, 2, 3 }
BOOST_CHECK(*it1 == 1);
BOOST_CHECK(*it2 == 4);
BOOST_CHECK(*it3 == 4);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 4);
BOOST_CHECK(cb[2] == 4);
BOOST_CHECK(cb[3] == 2);
BOOST_CHECK(cb[4] == 3);
BOOST_TEST(*it1 == 1);
BOOST_TEST(*it2 == 4);
BOOST_TEST(*it3 == 4);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 4);
BOOST_TEST(cb[2] == 4);
BOOST_TEST(cb[3] == 2);
BOOST_TEST(cb[4] == 3);
// it4 -> 2, it5 -> 3
circular_buffer<int>::iterator it4 = it1 + 3;
@@ -106,16 +106,16 @@ void validity_insert_n_test() {
// memory placement: { 3, 5, 4, 4, 2 } - 5 inserted only once
// circular buffer: { 5, 4, 4, 2, 3 }
BOOST_CHECK(*it1 == 3);
BOOST_CHECK(*it2 == 5);
BOOST_CHECK(*it3 == 4);
BOOST_CHECK(*it4 == 4);
BOOST_CHECK(*it5 == 2);
BOOST_CHECK(cb[0] == 5);
BOOST_CHECK(cb[1] == 4);
BOOST_CHECK(cb[2] == 4);
BOOST_CHECK(cb[3] == 2);
BOOST_CHECK(cb[4] == 3);
BOOST_TEST(*it1 == 3);
BOOST_TEST(*it2 == 5);
BOOST_TEST(*it3 == 4);
BOOST_TEST(*it4 == 4);
BOOST_TEST(*it5 == 2);
BOOST_TEST(cb[0] == 5);
BOOST_TEST(cb[1] == 4);
BOOST_TEST(cb[2] == 4);
BOOST_TEST(cb[3] == 2);
BOOST_TEST(cb[4] == 3);
}
void validity_insert_range_test() {
@@ -145,14 +145,14 @@ void validity_insert_range_test() {
// memory placement: { 1, 4, 5, 2, 3 }
// circular buffer: { 1, 4, 5, 2, 3 }
BOOST_CHECK(*it11 == 1);
BOOST_CHECK(*it12 == 4);
BOOST_CHECK(*it13 == 5);
BOOST_CHECK(cb1[0] == 1);
BOOST_CHECK(cb1[1] == 4);
BOOST_CHECK(cb1[2] == 5);
BOOST_CHECK(cb1[3] == 2);
BOOST_CHECK(cb1[4] == 3);
BOOST_TEST(*it11 == 1);
BOOST_TEST(*it12 == 4);
BOOST_TEST(*it13 == 5);
BOOST_TEST(cb1[0] == 1);
BOOST_TEST(cb1[1] == 4);
BOOST_TEST(cb1[2] == 5);
BOOST_TEST(cb1[3] == 2);
BOOST_TEST(cb1[4] == 3);
// it14 -> 2, it15 -> 3
circular_buffer<int>::iterator it14 = it11 + 3;
@@ -162,16 +162,16 @@ void validity_insert_range_test() {
// memory placement: { 3, 7, 4, 5, 2 } - 7 inserted only
// circular buffer: { 7, 4, 5, 2, 3 }
BOOST_CHECK(*it11 == 3);
BOOST_CHECK(*it12 == 7);
BOOST_CHECK(*it13 == 4);
BOOST_CHECK(*it14 == 5);
BOOST_CHECK(*it15 == 2);
BOOST_CHECK(cb1[0] == 7);
BOOST_CHECK(cb1[1] == 4);
BOOST_CHECK(cb1[2] == 5);
BOOST_CHECK(cb1[3] == 2);
BOOST_CHECK(cb1[4] == 3);
BOOST_TEST(*it11 == 3);
BOOST_TEST(*it12 == 7);
BOOST_TEST(*it13 == 4);
BOOST_TEST(*it14 == 5);
BOOST_TEST(*it15 == 2);
BOOST_TEST(cb1[0] == 7);
BOOST_TEST(cb1[1] == 4);
BOOST_TEST(cb1[2] == 5);
BOOST_TEST(cb1[3] == 2);
BOOST_TEST(cb1[4] == 3);
// memory placement: { 1, 2, 3 }
// circular buffer: { 1, 2, 3 }
@@ -189,14 +189,14 @@ void validity_insert_range_test() {
// memory placement: { 1, 4, 5, 2, 3 }
// circular buffer: { 1, 4, 5, 2, 3 }
BOOST_CHECK(*it21 == 1);
BOOST_CHECK(*it22 == 4);
BOOST_CHECK(*it23 == 5);
BOOST_CHECK(cb2[0] == 1);
BOOST_CHECK(cb2[1] == 4);
BOOST_CHECK(cb2[2] == 5);
BOOST_CHECK(cb2[3] == 2);
BOOST_CHECK(cb2[4] == 3);
BOOST_TEST(*it21 == 1);
BOOST_TEST(*it22 == 4);
BOOST_TEST(*it23 == 5);
BOOST_TEST(cb2[0] == 1);
BOOST_TEST(cb2[1] == 4);
BOOST_TEST(cb2[2] == 5);
BOOST_TEST(cb2[3] == 2);
BOOST_TEST(cb2[4] == 3);
// it24 -> 2, it25 -> 3
circular_buffer<int>::iterator it24 = it21 + 3;
@@ -206,16 +206,16 @@ void validity_insert_range_test() {
// memory placement: { 2, 3, 7, 4, 5 } - using input iterator inserts all items even if they are later replaced
// circular buffer: { 7, 4, 5, 2, 3 }
BOOST_CHECK(*it21 == 2);
BOOST_CHECK(*it22 == 3);
BOOST_CHECK(*it23 == 7);
BOOST_CHECK(*it24 == 4);
BOOST_CHECK(*it25 == 5);
BOOST_CHECK(cb2[0] == 7);
BOOST_CHECK(cb2[1] == 4);
BOOST_CHECK(cb2[2] == 5);
BOOST_CHECK(cb2[3] == 2);
BOOST_CHECK(cb2[4] == 3);
BOOST_TEST(*it21 == 2);
BOOST_TEST(*it22 == 3);
BOOST_TEST(*it23 == 7);
BOOST_TEST(*it24 == 4);
BOOST_TEST(*it25 == 5);
BOOST_TEST(cb2[0] == 7);
BOOST_TEST(cb2[1] == 4);
BOOST_TEST(cb2[2] == 5);
BOOST_TEST(cb2[3] == 2);
BOOST_TEST(cb2[4] == 3);
}
void validity_rinsert_test() {
@@ -235,13 +235,13 @@ void validity_rinsert_test() {
// memory placement: { 2, 4, 3, 1 }
// circular buffer: { 1, 2, 4, 3 }
BOOST_CHECK(*it1 == 2);
BOOST_CHECK(*it2 == 4);
BOOST_CHECK(*it3 == 3);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 2);
BOOST_CHECK(cb[2] == 4);
BOOST_CHECK(cb[3] == 3);
BOOST_TEST(*it1 == 2);
BOOST_TEST(*it2 == 4);
BOOST_TEST(*it3 == 3);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 2);
BOOST_TEST(cb[2] == 4);
BOOST_TEST(cb[3] == 3);
// it4 -> 1
circular_buffer<int>::iterator it4 = it1 - 1;
@@ -250,14 +250,14 @@ void validity_rinsert_test() {
// memory placement: { 5, 4, 1, 2 }
// circular buffer: { 1, 2, 5, 4 }
BOOST_CHECK(*it1 == 5);
BOOST_CHECK(*it2 == 4);
BOOST_CHECK(*it3 == 1);
BOOST_CHECK(*it4 == 2);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 2);
BOOST_CHECK(cb[2] == 5);
BOOST_CHECK(cb[3] == 4);
BOOST_TEST(*it1 == 5);
BOOST_TEST(*it2 == 4);
BOOST_TEST(*it3 == 1);
BOOST_TEST(*it4 == 2);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 2);
BOOST_TEST(cb[2] == 5);
BOOST_TEST(cb[3] == 4);
}
void validity_rinsert_n_test() {
@@ -278,14 +278,14 @@ void validity_rinsert_n_test() {
// memory placement: { 4, 4, 3, 1, 2 }
// circular buffer: { 1, 2, 4, 4, 3 }
BOOST_CHECK(*it1 == 4);
BOOST_CHECK(*it2 == 4);
BOOST_CHECK(*it3 == 3);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 2);
BOOST_CHECK(cb[2] == 4);
BOOST_CHECK(cb[3] == 4);
BOOST_CHECK(cb[4] == 3);
BOOST_TEST(*it1 == 4);
BOOST_TEST(*it2 == 4);
BOOST_TEST(*it3 == 3);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 2);
BOOST_TEST(cb[2] == 4);
BOOST_TEST(cb[3] == 4);
BOOST_TEST(cb[4] == 3);
// it4 -> 1, it5 -> 2
circular_buffer<int>::iterator it4 = it1 - 2;
@@ -295,16 +295,16 @@ void validity_rinsert_n_test() {
// memory placement: { 4, 5, 1, 2, 4 } - 5 inserted only once
// circular buffer: { 1, 2, 4, 4, 5 }
BOOST_CHECK(*it1 == 4);
BOOST_CHECK(*it2 == 5);
BOOST_CHECK(*it3 == 1);
BOOST_CHECK(*it4 == 2);
BOOST_CHECK(*it5 == 4);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 2);
BOOST_CHECK(cb[2] == 4);
BOOST_CHECK(cb[3] == 4);
BOOST_CHECK(cb[4] == 5);
BOOST_TEST(*it1 == 4);
BOOST_TEST(*it2 == 5);
BOOST_TEST(*it3 == 1);
BOOST_TEST(*it4 == 2);
BOOST_TEST(*it5 == 4);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 2);
BOOST_TEST(cb[2] == 4);
BOOST_TEST(cb[3] == 4);
BOOST_TEST(cb[4] == 5);
}
void validity_rinsert_range_test() {
@@ -334,14 +334,14 @@ void validity_rinsert_range_test() {
// memory placement: { 4, 5, 3, 1, 2 }
// circular buffer: { 1, 2, 4, 5, 3 }
BOOST_CHECK(*it11 == 4);
BOOST_CHECK(*it12 == 5);
BOOST_CHECK(*it13 == 3);
BOOST_CHECK(cb1[0] == 1);
BOOST_CHECK(cb1[1] == 2);
BOOST_CHECK(cb1[2] == 4);
BOOST_CHECK(cb1[3] == 5);
BOOST_CHECK(cb1[4] == 3);
BOOST_TEST(*it11 == 4);
BOOST_TEST(*it12 == 5);
BOOST_TEST(*it13 == 3);
BOOST_TEST(cb1[0] == 1);
BOOST_TEST(cb1[1] == 2);
BOOST_TEST(cb1[2] == 4);
BOOST_TEST(cb1[3] == 5);
BOOST_TEST(cb1[4] == 3);
// it14 -> 1, it15 -> 2
circular_buffer<int>::iterator it14 = it11 - 2;
@@ -351,16 +351,16 @@ void validity_rinsert_range_test() {
// memory placement: { 5, 6, 1, 2, 4 } - 6 inserted only
// circular buffer: { 1, 2, 4, 5, 6 }
BOOST_CHECK(*it11 == 5);
BOOST_CHECK(*it12 == 6);
BOOST_CHECK(*it13 == 1);
BOOST_CHECK(*it14 == 2);
BOOST_CHECK(*it15 == 4);
BOOST_CHECK(cb1[0] == 1);
BOOST_CHECK(cb1[1] == 2);
BOOST_CHECK(cb1[2] == 4);
BOOST_CHECK(cb1[3] == 5);
BOOST_CHECK(cb1[4] == 6);
BOOST_TEST(*it11 == 5);
BOOST_TEST(*it12 == 6);
BOOST_TEST(*it13 == 1);
BOOST_TEST(*it14 == 2);
BOOST_TEST(*it15 == 4);
BOOST_TEST(cb1[0] == 1);
BOOST_TEST(cb1[1] == 2);
BOOST_TEST(cb1[2] == 4);
BOOST_TEST(cb1[3] == 5);
BOOST_TEST(cb1[4] == 6);
// memory placement: { 1, 2, 3 }
// circular buffer: { 1, 2, 3 }
@@ -378,14 +378,14 @@ void validity_rinsert_range_test() {
// memory placement: { 4, 5, 3, 1, 2 }
// circular buffer: { 1, 2, 4, 5, 3 }
BOOST_CHECK(*it21 == 4);
BOOST_CHECK(*it22 == 5);
BOOST_CHECK(*it23 == 3);
BOOST_CHECK(cb2[0] == 1);
BOOST_CHECK(cb2[1] == 2);
BOOST_CHECK(cb2[2] == 4);
BOOST_CHECK(cb2[3] == 5);
BOOST_CHECK(cb2[4] == 3);
BOOST_TEST(*it21 == 4);
BOOST_TEST(*it22 == 5);
BOOST_TEST(*it23 == 3);
BOOST_TEST(cb2[0] == 1);
BOOST_TEST(cb2[1] == 2);
BOOST_TEST(cb2[2] == 4);
BOOST_TEST(cb2[3] == 5);
BOOST_TEST(cb2[4] == 3);
// it24 -> 1, it25 -> 2
circular_buffer<int>::iterator it24 = it21 - 2;
@@ -395,16 +395,16 @@ void validity_rinsert_range_test() {
// memory placement: { 5, 6, 1, 2, 4 }
// circular buffer: { 1, 2, 4, 5, 6 }
BOOST_CHECK(*it21 == 5);
BOOST_CHECK(*it22 == 6);
BOOST_CHECK(*it23 == 1);
BOOST_CHECK(*it24 == 2);
BOOST_CHECK(*it25 == 4);
BOOST_CHECK(cb2[0] == 1);
BOOST_CHECK(cb2[1] == 2);
BOOST_CHECK(cb2[2] == 4);
BOOST_CHECK(cb2[3] == 5);
BOOST_CHECK(cb2[4] == 6);
BOOST_TEST(*it21 == 5);
BOOST_TEST(*it22 == 6);
BOOST_TEST(*it23 == 1);
BOOST_TEST(*it24 == 2);
BOOST_TEST(*it25 == 4);
BOOST_TEST(cb2[0] == 1);
BOOST_TEST(cb2[1] == 2);
BOOST_TEST(cb2[2] == 4);
BOOST_TEST(cb2[3] == 5);
BOOST_TEST(cb2[4] == 6);
}
void validity_erase_test() {
@@ -430,14 +430,14 @@ void validity_erase_test() {
// memory placement: { 5, X, 1, 3, 4 }
// circular buffer: { 1, 3, 4, 5 }
BOOST_CHECK(*it1 == 1);
BOOST_CHECK(*it2 == 3);
BOOST_CHECK(*it3 == 4);
BOOST_CHECK(*it4 == 5);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 3);
BOOST_CHECK(cb[2] == 4);
BOOST_CHECK(cb[3] == 5);
BOOST_TEST(*it1 == 1);
BOOST_TEST(*it2 == 3);
BOOST_TEST(*it3 == 4);
BOOST_TEST(*it4 == 5);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 3);
BOOST_TEST(cb[2] == 4);
BOOST_TEST(cb[3] == 5);
}
void validity_erase_range_test() {
@@ -465,14 +465,14 @@ void validity_erase_range_test() {
// memory placement: { 6, X, X, 1, 2, 5 }
// circular buffer: { 1, 2, 5, 6 }
BOOST_CHECK(*it1 == 1);
BOOST_CHECK(*it2 == 2);
BOOST_CHECK(*it3 == 5);
BOOST_CHECK(*it4 == 6);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 2);
BOOST_CHECK(cb[2] == 5);
BOOST_CHECK(cb[3] == 6);
BOOST_TEST(*it1 == 1);
BOOST_TEST(*it2 == 2);
BOOST_TEST(*it3 == 5);
BOOST_TEST(*it4 == 6);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 2);
BOOST_TEST(cb[2] == 5);
BOOST_TEST(cb[3] == 6);
}
void validity_rerase_test() {
@@ -498,14 +498,14 @@ void validity_rerase_test() {
// memory placement: { 4, 5, X, 1, 3 }
// circular buffer: { 1, 3, 4, 5 }
BOOST_CHECK(*it1 == 1);
BOOST_CHECK(*it2 == 3);
BOOST_CHECK(*it3 == 4);
BOOST_CHECK(*it4 == 5);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 3);
BOOST_CHECK(cb[2] == 4);
BOOST_CHECK(cb[3] == 5);
BOOST_TEST(*it1 == 1);
BOOST_TEST(*it2 == 3);
BOOST_TEST(*it3 == 4);
BOOST_TEST(*it4 == 5);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 3);
BOOST_TEST(cb[2] == 4);
BOOST_TEST(cb[3] == 5);
}
void validity_rerase_range_test() {
@@ -533,14 +533,14 @@ void validity_rerase_range_test() {
// memory placement: { 2, 5, 6, X, X, 1 }
// circular buffer: { 1, 2, 5, 6 }
BOOST_CHECK(*it1 == 1);
BOOST_CHECK(*it2 == 2);
BOOST_CHECK(*it3 == 5);
BOOST_CHECK(*it4 == 6);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 2);
BOOST_CHECK(cb[2] == 5);
BOOST_CHECK(cb[3] == 6);
BOOST_TEST(*it1 == 1);
BOOST_TEST(*it2 == 2);
BOOST_TEST(*it3 == 5);
BOOST_TEST(*it4 == 6);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 2);
BOOST_TEST(cb[2] == 5);
BOOST_TEST(cb[3] == 6);
}
void validity_linearize_test() {
@@ -562,12 +562,12 @@ void validity_linearize_test() {
// memory placement: { 1, 2, 3 }
// circular buffer: { 1, 2, 3 }
BOOST_CHECK(*it1 == 2);
BOOST_CHECK(*it2 == 3);
BOOST_CHECK(*it3 == 1);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 2);
BOOST_CHECK(cb[2] == 3);
BOOST_TEST(*it1 == 2);
BOOST_TEST(*it2 == 3);
BOOST_TEST(*it3 == 1);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 2);
BOOST_TEST(cb[2] == 3);
}
void validity_swap_test() {
@@ -602,18 +602,18 @@ void validity_swap_test() {
// Although iterators refer to the original elements,
// their internal state is inconsistent and no other operation
// (except dereferencing) can be invoked on them any more.
BOOST_CHECK(*it11 == 1);
BOOST_CHECK(*it12 == 2);
BOOST_CHECK(*it13 == 3);
BOOST_CHECK(*it21 == 4);
BOOST_CHECK(*it22 == 5);
BOOST_CHECK(*it23 == 6);
BOOST_CHECK(cb1[0] == 4);
BOOST_CHECK(cb1[1] == 5);
BOOST_CHECK(cb1[2] == 6);
BOOST_CHECK(cb2[0] == 1);
BOOST_CHECK(cb2[1] == 2);
BOOST_CHECK(cb2[2] == 3);
BOOST_TEST(*it11 == 1);
BOOST_TEST(*it12 == 2);
BOOST_TEST(*it13 == 3);
BOOST_TEST(*it21 == 4);
BOOST_TEST(*it22 == 5);
BOOST_TEST(*it23 == 6);
BOOST_TEST(cb1[0] == 4);
BOOST_TEST(cb1[1] == 5);
BOOST_TEST(cb1[2] == 6);
BOOST_TEST(cb2[0] == 1);
BOOST_TEST(cb2[1] == 2);
BOOST_TEST(cb2[2] == 3);
}
void validity_push_back_test() {
@@ -635,12 +635,12 @@ void validity_push_back_test() {
// memory placement: { 3, 4, 2 }
// circular buffer: { 2, 3, 4 }
BOOST_CHECK(*it1 == 4);
BOOST_CHECK(*it2 == 2);
BOOST_CHECK(*it3 == 3);
BOOST_CHECK(cb[0] == 2);
BOOST_CHECK(cb[1] == 3);
BOOST_CHECK(cb[2] == 4);
BOOST_TEST(*it1 == 4);
BOOST_TEST(*it2 == 2);
BOOST_TEST(*it3 == 3);
BOOST_TEST(cb[0] == 2);
BOOST_TEST(cb[1] == 3);
BOOST_TEST(cb[2] == 4);
}
void validity_push_front_test() {
@@ -662,12 +662,12 @@ void validity_push_front_test() {
// memory placement: { 4, 1, 2 }
// circular buffer: { 4, 1, 2 }
BOOST_CHECK(*it1 == 1);
BOOST_CHECK(*it2 == 2);
BOOST_CHECK(*it3 == 4);
BOOST_CHECK(cb[0] == 4);
BOOST_CHECK(cb[1] == 1);
BOOST_CHECK(cb[2] == 2);
BOOST_TEST(*it1 == 1);
BOOST_TEST(*it2 == 2);
BOOST_TEST(*it3 == 4);
BOOST_TEST(cb[0] == 4);
BOOST_TEST(cb[1] == 1);
BOOST_TEST(cb[2] == 2);
}
void validity_pop_back_test() {
@@ -688,10 +688,10 @@ void validity_pop_back_test() {
// memory placement: { X, 1, 2 }
// circular buffer: { 1, 2 }
BOOST_CHECK(*it1 == 1);
BOOST_CHECK(*it2 == 2);
BOOST_CHECK(cb[0] == 1);
BOOST_CHECK(cb[1] == 2);
BOOST_TEST(*it1 == 1);
BOOST_TEST(*it2 == 2);
BOOST_TEST(cb[0] == 1);
BOOST_TEST(cb[1] == 2);
}
void validity_pop_front_test() {
@@ -712,34 +712,31 @@ void validity_pop_front_test() {
// memory placement: { 3, X, 2 }
// circular buffer: { 2, 3 }
BOOST_CHECK(*it1 == 2);
BOOST_CHECK(*it2 == 3);
BOOST_CHECK(cb[0] == 2);
BOOST_CHECK(cb[1] == 3);
BOOST_TEST(*it1 == 2);
BOOST_TEST(*it2 == 3);
BOOST_TEST(cb[0] == 2);
BOOST_TEST(cb[1] == 3);
}
// test main
test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
test_suite* tests = BOOST_TEST_SUITE("Unit tests for the iterator of the circular_buffer.");
tests->add(BOOST_TEST_CASE(&validity_example_test));
tests->add(BOOST_TEST_CASE(&validity_insert_test));
tests->add(BOOST_TEST_CASE(&validity_insert_n_test));
tests->add(BOOST_TEST_CASE(&validity_insert_range_test));
tests->add(BOOST_TEST_CASE(&validity_rinsert_test));
tests->add(BOOST_TEST_CASE(&validity_rinsert_n_test));
tests->add(BOOST_TEST_CASE(&validity_rinsert_range_test));
tests->add(BOOST_TEST_CASE(&validity_erase_test));
tests->add(BOOST_TEST_CASE(&validity_erase_range_test));
tests->add(BOOST_TEST_CASE(&validity_rerase_test));
tests->add(BOOST_TEST_CASE(&validity_rerase_range_test));
tests->add(BOOST_TEST_CASE(&validity_linearize_test));
tests->add(BOOST_TEST_CASE(&validity_swap_test));
tests->add(BOOST_TEST_CASE(&validity_push_back_test));
tests->add(BOOST_TEST_CASE(&validity_push_front_test));
tests->add(BOOST_TEST_CASE(&validity_pop_back_test));
tests->add(BOOST_TEST_CASE(&validity_pop_front_test));
return tests;
int main()
{
validity_example_test();
validity_insert_test();
validity_insert_n_test();
validity_insert_range_test();
validity_rinsert_test();
validity_rinsert_n_test();
validity_rinsert_range_test();
validity_erase_test();
validity_erase_range_test();
validity_rerase_test();
validity_rerase_range_test();
validity_linearize_test();
validity_swap_test();
validity_push_back_test();
validity_push_front_test();
validity_pop_back_test();
validity_pop_front_test();
return boost::report_errors();
}
test/space_optimized_test.cpp
+66 -69
View File
@@ -29,33 +29,33 @@ void min_capacity_test() {
cb_space_optimized cb2(capacity_ctrl(10, 5), 1);
cb_space_optimized cb3(capacity_ctrl(20, 10), v.begin(), v.end());
BOOST_CHECK(cb1.size() == 0);
BOOST_CHECK(cb1.capacity().capacity() == 10);
BOOST_CHECK(cb1.capacity().min_capacity() == 10);
BOOST_CHECK(cb2[0] == 1);
BOOST_CHECK(cb2.size() == 10);
BOOST_CHECK(cb2.capacity() == 10);
BOOST_CHECK(cb2.capacity().min_capacity() == 5);
BOOST_CHECK(cb3[0] == 1);
BOOST_CHECK(cb3.size() == 5);
BOOST_CHECK(cb3.capacity() == 20);
BOOST_CHECK(cb3.capacity().min_capacity() == 10);
BOOST_CHECK(cb1.capacity().min_capacity() <= cb1.internal_capacity());
BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
BOOST_CHECK(cb3.capacity().min_capacity() <= cb3.internal_capacity());
BOOST_TEST(cb1.size() == 0);
BOOST_TEST(cb1.capacity().capacity() == 10);
BOOST_TEST(cb1.capacity().min_capacity() == 10);
BOOST_TEST(cb2[0] == 1);
BOOST_TEST(cb2.size() == 10);
BOOST_TEST(cb2.capacity() == 10);
BOOST_TEST(cb2.capacity().min_capacity() == 5);
BOOST_TEST(cb3[0] == 1);
BOOST_TEST(cb3.size() == 5);
BOOST_TEST(cb3.capacity() == 20);
BOOST_TEST(cb3.capacity().min_capacity() == 10);
BOOST_TEST(cb1.capacity().min_capacity() <= cb1.internal_capacity());
BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
BOOST_TEST(cb3.capacity().min_capacity() <= cb3.internal_capacity());
cb2.erase(cb2.begin() + 2, cb2.end());
BOOST_CHECK(cb2.size() == 2);
BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
BOOST_TEST(cb2.size() == 2);
BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
cb2.clear();
cb3.clear();
BOOST_CHECK(cb2.empty());
BOOST_CHECK(cb3.empty());
BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
BOOST_CHECK(cb3.capacity().min_capacity() <= cb3.internal_capacity());
BOOST_TEST(cb2.empty());
BOOST_TEST(cb3.empty());
BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
BOOST_TEST(cb3.capacity().min_capacity() <= cb3.internal_capacity());
}
void capacity_control_test() {
@@ -65,33 +65,33 @@ void capacity_control_test() {
circular_buffer_space_optimized<int>::capacity_type(20, 5);
circular_buffer_space_optimized<int>::capacity_type c3 = c2;
BOOST_CHECK(c1.capacity() == 10);
BOOST_CHECK(c1.min_capacity() == 0);
BOOST_CHECK(c2.capacity() == 20);
BOOST_CHECK(c2.min_capacity() == 5);
BOOST_CHECK(c3.capacity() == 20);
BOOST_CHECK(c3.min_capacity() == 5);
BOOST_TEST(c1.capacity() == 10);
BOOST_TEST(c1.min_capacity() == 0);
BOOST_TEST(c2.capacity() == 20);
BOOST_TEST(c2.min_capacity() == 5);
BOOST_TEST(c3.capacity() == 20);
BOOST_TEST(c3.min_capacity() == 5);
c1 = c2;
BOOST_CHECK(c1.capacity() == 20);
BOOST_CHECK(c1.min_capacity() == 5);
BOOST_TEST(c1.capacity() == 20);
BOOST_TEST(c1.min_capacity() == 5);
}
void specific_constructors_test() {
cb_space_optimized cb1;
BOOST_CHECK(cb1.capacity() == 0);
BOOST_CHECK(cb1.capacity().min_capacity() == 0);
BOOST_CHECK(cb1.internal_capacity() == 0);
BOOST_CHECK(cb1.size() == 0);
BOOST_TEST(cb1.capacity() == 0);
BOOST_TEST(cb1.capacity().min_capacity() == 0);
BOOST_TEST(cb1.internal_capacity() == 0);
BOOST_TEST(cb1.size() == 0);
cb1.push_back(1);
cb1.push_back(2);
cb1.push_back(3);
BOOST_CHECK(cb1.size() == 0);
BOOST_CHECK(cb1.capacity() == 0);
BOOST_TEST(cb1.size() == 0);
BOOST_TEST(cb1.capacity() == 0);
vector<int> v;
v.push_back(1);
@@ -100,9 +100,9 @@ void specific_constructors_test() {
cb_space_optimized cb2(v.begin(), v.end());
BOOST_CHECK(cb2.capacity() == 3);
BOOST_CHECK(cb2.capacity().min_capacity() == 0);
BOOST_CHECK(cb2.size() == 3);
BOOST_TEST(cb2.capacity() == 3);
BOOST_TEST(cb2.capacity().min_capacity() == 0);
BOOST_TEST(cb2.size() == 3);
}
void shrink_to_fit_test() {
@@ -112,15 +112,15 @@ void shrink_to_fit_test() {
cb.push_back(2);
cb.push_back(3);
BOOST_CHECK(cb.size() == 3);
BOOST_CHECK(cb.capacity() == 1000);
BOOST_TEST(cb.size() == 3);
BOOST_TEST(cb.capacity() == 1000);
size_t internal_capacity = cb.internal_capacity();
cb_space_optimized(cb).swap(cb);
BOOST_CHECK(cb.size() == 3);
BOOST_CHECK(cb.capacity() == 1000);
BOOST_CHECK(internal_capacity >= cb.internal_capacity());
BOOST_TEST(cb.size() == 3);
BOOST_TEST(cb.capacity() == 1000);
BOOST_TEST(internal_capacity >= cb.internal_capacity());
}
void iterator_invalidation_test() {
@@ -136,33 +136,33 @@ void iterator_invalidation_test() {
cb_space_optimized::iterator it3 = cb1.begin() + 6;
cb1.set_capacity(10);
BOOST_CHECK(it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
BOOST_TEST(it1.is_valid(&cb1));
BOOST_TEST(!it2.is_valid(&cb1));
BOOST_TEST(!it3.is_valid(&cb1));
it1 = cb1.end();
it2 = cb1.begin();
it3 = cb1.begin() + 6;
cb1.rset_capacity(10);
BOOST_CHECK(it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
BOOST_TEST(it1.is_valid(&cb1));
BOOST_TEST(!it2.is_valid(&cb1));
BOOST_TEST(!it3.is_valid(&cb1));
it1 = cb1.end();
it2 = cb1.begin();
it3 = cb1.begin() + 6;
cb1.resize(10);
BOOST_CHECK(it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
BOOST_TEST(it1.is_valid(&cb1));
BOOST_TEST(!it2.is_valid(&cb1));
BOOST_TEST(!it3.is_valid(&cb1));
it1 = cb1.end();
it2 = cb1.begin();
it3 = cb1.begin() + 6;
cb1.rresize(10);
BOOST_CHECK(it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
BOOST_TEST(it1.is_valid(&cb1));
BOOST_TEST(!it2.is_valid(&cb1));
BOOST_TEST(!it3.is_valid(&cb1));
{
cb_space_optimized cb2(10, 1);
@@ -173,24 +173,21 @@ void iterator_invalidation_test() {
it2 = cb2.begin();
it3 = cb2.begin() + 6;
}
BOOST_CHECK(!it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
BOOST_TEST(!it1.is_valid(&cb1));
BOOST_TEST(!it2.is_valid(&cb1));
BOOST_TEST(!it3.is_valid(&cb1));
#endif // #if BOOST_CB_ENABLE_DEBUG
}
// test main
test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
test_suite* tests = BOOST_TEST_SUITE("Unit tests for the circular_buffer_space_optimized.");
add_common_tests(tests);
tests->add(BOOST_TEST_CASE(&min_capacity_test));
tests->add(BOOST_TEST_CASE(&capacity_control_test));
tests->add(BOOST_TEST_CASE(&specific_constructors_test));
tests->add(BOOST_TEST_CASE(&shrink_to_fit_test));
tests->add(BOOST_TEST_CASE(&iterator_invalidation_test));
return tests;
int main()
{
run_common_tests();
min_capacity_test();
capacity_control_test();
specific_constructors_test();
shrink_to_fit_test();
iterator_invalidation_test();
return boost::report_errors();
}
test/test.hpp
+1 -2
View File
@@ -16,7 +16,7 @@
#define BOOST_CB_TEST
#include <boost/circular_buffer.hpp>
#include <boost/test/included/unit_test.hpp>
#include <boost/core/lightweight_test.hpp>
#include <iterator>
#include <numeric>
#include <vector>
@@ -139,7 +139,6 @@ inline ptrdiff_t* distance_type(const MyInputIterator&) { return 0; }
#endif // #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR)
using boost::unit_test::test_suite;
using namespace boost;
using namespace std;