diff options
Diffstat (limited to 'src/boost/libs/circular_buffer')
18 files changed, 5764 insertions, 0 deletions
diff --git a/src/boost/libs/circular_buffer/CMakeLists.txt b/src/boost/libs/circular_buffer/CMakeLists.txt new file mode 100644 index 000000000..1926e7300 --- /dev/null +++ b/src/boost/libs/circular_buffer/CMakeLists.txt @@ -0,0 +1,25 @@ +# Copyright 2018 Glen Joseph Fernandes +# (glenjofe@gmail.com) +# +# Distributed under the Boost Software License, Version 1.0. +# (http://www.boost.org/LICENSE_1_0.txt) + +cmake_minimum_required(VERSION 3.5) + +project(BoostCircularBuffer LANGUAGES CXX) + +add_library(boost_circular_buffer INTERFACE) + +add_library(Boost::circular_buffer ALIAS boost_circular_buffer) + +target_include_directories(boost_circular_buffer INTERFACE include) + +target_link_libraries(boost_circular_buffer INTERFACE + Boost::assert + Boost::concept_check + Boost::config + Boost::core + Boost::move + Boost::static_assert + Boost::throw_exception + Boost::type_traits) diff --git a/src/boost/libs/circular_buffer/example/bounded_buffer_comparison.cpp b/src/boost/libs/circular_buffer/example/bounded_buffer_comparison.cpp new file mode 100644 index 000000000..9eba99648 --- /dev/null +++ b/src/boost/libs/circular_buffer/example/bounded_buffer_comparison.cpp @@ -0,0 +1,316 @@ +// Comparison of bounded buffers based on different containers. + +// Copyright (c) 2003-2008 Jan Gaspar +// Copyright 2013 Paul A. Bristow. Added some Quickbook snippet markers. + +// 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 <boost/circular_buffer.hpp> +#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/bind.hpp> +#include <deque> +#include <list> +#include <string> +#include <iostream> + +const unsigned long QUEUE_SIZE = 1000L; +const unsigned long TOTAL_ELEMENTS = QUEUE_SIZE * 1000L; + +template <class T> +class bounded_buffer { +public: + + typedef boost::circular_buffer<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer(size_type capacity) : m_unread(0), m_container(capacity) {} + + void push_front(param_type item) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_full, this)); + m_container.push_front(item); + ++m_unread; + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_empty, this)); + *pItem = m_container[--m_unread]; + lock.unlock(); + m_not_full.notify_one(); + } + +private: + bounded_buffer(const bounded_buffer&); // Disabled copy constructor + bounded_buffer& operator = (const bounded_buffer&); // Disabled assign operator + + bool is_not_empty() const { return m_unread > 0; } + bool is_not_full() const { return m_unread < m_container.capacity(); } + + size_type m_unread; + container_type m_container; + boost::mutex m_mutex; + boost::condition m_not_empty; + boost::condition m_not_full; +}; + +template <class T> +class bounded_buffer_space_optimized { +public: + + typedef boost::circular_buffer_space_optimized<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer_space_optimized(size_type capacity) : m_container(capacity) {} + + void push_front(param_type item) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer_space_optimized<value_type>::is_not_full, this)); + m_container.push_front(item); + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer_space_optimized<value_type>::is_not_empty, this)); + *pItem = m_container.back(); + m_container.pop_back(); + lock.unlock(); + m_not_full.notify_one(); + } + +private: + + bounded_buffer_space_optimized(const bounded_buffer_space_optimized&); // Disabled copy constructor + bounded_buffer_space_optimized& operator = (const bounded_buffer_space_optimized&); // Disabled assign operator + + bool is_not_empty() const { return m_container.size() > 0; } + bool is_not_full() const { return m_container.size() < m_container.capacity(); } + + container_type m_container; + boost::mutex m_mutex; + boost::condition m_not_empty; + boost::condition m_not_full; +}; + +template <class T> +class bounded_buffer_deque_based { +public: + + typedef std::deque<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer_deque_based(size_type capacity) : m_capacity(capacity) {} + + void push_front(param_type item) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer_deque_based<value_type>::is_not_full, this)); + m_container.push_front(item); + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer_deque_based<value_type>::is_not_empty, this)); + *pItem = m_container.back(); + m_container.pop_back(); + lock.unlock(); + m_not_full.notify_one(); + } + +private: + + bounded_buffer_deque_based(const bounded_buffer_deque_based&); // Disabled copy constructor + bounded_buffer_deque_based& operator = (const bounded_buffer_deque_based&); // Disabled assign operator + + bool is_not_empty() const { return m_container.size() > 0; } + bool is_not_full() const { return m_container.size() < m_capacity; } + + const size_type m_capacity; + container_type m_container; + boost::mutex m_mutex; + boost::condition m_not_empty; + boost::condition m_not_full; +}; + +template <class T> +class bounded_buffer_list_based { +public: + + typedef std::list<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer_list_based(size_type capacity) : m_capacity(capacity) {} + + void push_front(param_type item) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer_list_based<value_type>::is_not_full, this)); + m_container.push_front(item); + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer_list_based<value_type>::is_not_empty, this)); + *pItem = m_container.back(); + m_container.pop_back(); + lock.unlock(); + m_not_full.notify_one(); + } + +private: + + bounded_buffer_list_based(const bounded_buffer_list_based&); // Disabled copy constructor + bounded_buffer_list_based& operator = (const bounded_buffer_list_based&); // Disabled assign operator + + bool is_not_empty() const { return m_container.size() > 0; } + bool is_not_full() const { return m_container.size() < m_capacity; } + + const size_type m_capacity; + container_type m_container; + boost::mutex m_mutex; + boost::condition m_not_empty; + boost::condition m_not_full; +}; + +template<class Buffer> +class Consumer { + + typedef typename Buffer::value_type value_type; + Buffer* m_container; + value_type m_item; + +public: + Consumer(Buffer* buffer) : m_container(buffer) {} + + void operator()() { + for (unsigned long i = 0L; i < TOTAL_ELEMENTS; ++i) { + m_container->pop_back(&m_item); + } + } +}; + +template<class Buffer> +class Producer { + + typedef typename Buffer::value_type value_type; + Buffer* m_container; + +public: + Producer(Buffer* buffer) : m_container(buffer) {} + + void operator()() { + for (unsigned long i = 0L; i < TOTAL_ELEMENTS; ++i) { + m_container->push_front(value_type()); + } + } +}; + +template<class Buffer> +void fifo_test(Buffer* buffer) { + + // Start of measurement + 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) { +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + buffer->push_front(Buffer::value_type()); +#else + buffer->push_front(BOOST_DEDUCED_TYPENAME Buffer::value_type()); +#endif + } + + Consumer<Buffer> consumer(buffer); + Producer<Buffer> producer(buffer); + + // Start the threads. + boost::thread consume(consumer); + boost::thread produce(producer); + + // Wait for completion. + consume.join(); + produce.join(); + + // End of measurement +} + +int main(int /*argc*/, char* /*argv*/[]) { + + bounded_buffer<int> bb_int(QUEUE_SIZE); + std::cout << "bounded_buffer<int> "; + fifo_test(&bb_int); + + bounded_buffer_space_optimized<int> bb_space_optimized_int(QUEUE_SIZE); + std::cout << "bounded_buffer_space_optimized<int> "; + fifo_test(&bb_space_optimized_int); + + bounded_buffer_deque_based<int> bb_deque_based_int(QUEUE_SIZE); + std::cout << "bounded_buffer_deque_based<int> "; + fifo_test(&bb_deque_based_int); + + bounded_buffer_list_based<int> bb_list_based_int(QUEUE_SIZE); + std::cout << "bounded_buffer_list_based<int> "; + fifo_test(&bb_list_based_int); + + bounded_buffer<std::string> bb_string(QUEUE_SIZE); + std::cout << "bounded_buffer<std::string> "; + fifo_test(&bb_string); + + bounded_buffer_space_optimized<std::string> bb_space_optimized_string(QUEUE_SIZE); + std::cout << "bounded_buffer_space_optimized<std::string> "; + fifo_test(&bb_space_optimized_string); + + bounded_buffer_deque_based<std::string> bb_deque_based_string(QUEUE_SIZE); + std::cout << "bounded_buffer_deque_based<std::string> "; + fifo_test(&bb_deque_based_string); + + bounded_buffer_list_based<std::string> bb_list_based_string(QUEUE_SIZE); + std::cout << "bounded_buffer_list_based<std::string> "; + fifo_test(&bb_list_based_string); + + return 0; +} +/* + +//[bounded_buffer_comparison_output + + Description: Autorun "J:\Cpp\Misc\Debug\bounded_buffer_comparison.exe" + bounded_buffer<int> 5.15 s + + bounded_buffer_space_optimized<int> 5.71 s + + bounded_buffer_deque_based<int> 15.57 s + + bounded_buffer_list_based<int> 17.33 s + + bounded_buffer<std::string> 24.49 s + + bounded_buffer_space_optimized<std::string> 28.33 s + + bounded_buffer_deque_based<std::string> 29.45 s + + bounded_buffer_list_based<std::string> 31.29 s + + //] //[bounded_buffer_comparison_output] + +*/ diff --git a/src/boost/libs/circular_buffer/example/circular_buffer_bound_example.cpp b/src/boost/libs/circular_buffer/example/circular_buffer_bound_example.cpp new file mode 100644 index 000000000..b5b7c12f7 --- /dev/null +++ b/src/boost/libs/circular_buffer/example/circular_buffer_bound_example.cpp @@ -0,0 +1,192 @@ +// Copyright 2003-2008 Jan Gaspar. +// Copyright 2013 Paul A. Bristow. Added some Quickbook snippet markers. + +// Distributed under the Boost Software License, Version 1.0. +// (See the accompanying file LICENSE_1_0.txt +// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.) + +//[circular_buffer_bound_example_1 +/*` +This example shows how the `circular_buffer` can be utilized +as an underlying container of the bounded buffer. +*/ + +#include <boost/circular_buffer.hpp> +#include <boost/thread/mutex.hpp> +#include <boost/thread/condition.hpp> +#include <boost/thread/thread.hpp> +#include <boost/call_traits.hpp> +#include <boost/bind.hpp> + +#include <boost/timer/timer.hpp> // for auto_cpu_timer +#include <iostream> + +template <class T> +class bounded_buffer +{ +public: + + typedef boost::circular_buffer<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer(size_type capacity) : m_unread(0), m_container(capacity) {} + + void push_front(typename boost::call_traits<value_type>::param_type item) + { // `param_type` represents the "best" way to pass a parameter of type `value_type` to a method. + + boost::mutex::scoped_lock lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_full, this)); + m_container.push_front(item); + ++m_unread; + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::mutex::scoped_lock lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_empty, this)); + *pItem = m_container[--m_unread]; + lock.unlock(); + m_not_full.notify_one(); + } + +private: + bounded_buffer(const bounded_buffer&); // Disabled copy constructor. + bounded_buffer& operator = (const bounded_buffer&); // Disabled assign operator. + + bool is_not_empty() const { return m_unread > 0; } + bool is_not_full() const { return m_unread < m_container.capacity(); } + + size_type m_unread; + container_type m_container; + boost::mutex m_mutex; + boost::condition m_not_empty; + boost::condition m_not_full; +}; // + +//] [/circular_buffer_bound_example_1] + +const unsigned long queue_size = 1000L; +const unsigned long total_elements = queue_size * 1000L; + +//[circular_buffer_bound_example_2] +/*`To demonstrate, create two classes to exercise the buffer. + +The producer class fills the buffer with elements. + +The consumer class consumes the buffer contents. + +*/ + +template<class Buffer> +class Producer +{ + + typedef typename Buffer::value_type value_type; + Buffer* m_container; + +public: + Producer(Buffer* buffer) : m_container(buffer) + {} + + void operator()() + { + for (unsigned long i = 0L; i < total_elements; ++i) + { + m_container->push_front(value_type()); + } + } +}; + +template<class Buffer> +class Consumer +{ + + typedef typename Buffer::value_type value_type; + Buffer* m_container; + value_type m_item; + +public: + Consumer(Buffer* buffer) : m_container(buffer) + {} + + void operator()() + { + for (unsigned long i = 0L; i < total_elements; ++i) + { + m_container->pop_back(&m_item); + } + } +}; + +/*`Create a first-int first-out test of the bound_buffer. +Include a call to boost::progress_timer + +[@http://www.boost.org/doc/libs/1_53_0/libs/timer/doc/cpu_timers.html CPU timer] + +*/ +template<class Buffer> +void fifo_test(Buffer* buffer) +{ + // Start of timing. + 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) + { +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + buffer->push_front(Buffer::value_type()); +#else + buffer->push_front(BOOST_DEDUCED_TYPENAME Buffer::value_type()); +#endif + } + + // Construct the threads. + Consumer<Buffer> consumer(buffer); + Producer<Buffer> producer(buffer); + + // Start the threads. + boost::thread consume(consumer); + boost::thread produce(producer); + + // Wait for completion. + consume.join(); + produce.join(); + + // End of timing. + // destructor of boost::timer::auto_cpu_timer will output the time to std::cout. + +} +//] [/circular_buffer_bound_example_2] + + +int main() +{ +//[circular_buffer_bound_example_3] + //`Construct a bounded_buffer to hold the chosen type, here int. + bounded_buffer<int> bb_int(queue_size); + std::cout << "Testing bounded_buffer<int> "; + + //`Start the fifo test. + fifo_test(&bb_int); + //` destructor of boost::timer::auto_cpu_timer will output the time to std::cout + +//] [/circular_buffer_bound_example_3] + +return 0; +} // int main() + +/* + +//[circular_buffer_bound_output + + Description: Autorun "J:\Cpp\Misc\Debug\circular_buffer_bound_example.exe" + + Testing bounded_buffer<int> 15.010692s wall, 9.188459s user + 7.207246s system = 16.395705s CPU (109.2%) + +//] [/circular_buffer_bound_output] +*/ + + diff --git a/src/boost/libs/circular_buffer/example/circular_buffer_example.cpp b/src/boost/libs/circular_buffer/example/circular_buffer_example.cpp new file mode 100644 index 000000000..010074122 --- /dev/null +++ b/src/boost/libs/circular_buffer/example/circular_buffer_example.cpp @@ -0,0 +1,63 @@ +// Copyright 2003-2008 Jan Gaspar. +// Copyright 2013 Paul A. Bristow. Added some Quickbook snippet markers. + +// Distributed under the Boost Software License, Version 1.0. +// (See the accompanying file LICENSE_1_0.txt +// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.) + +//[circular_buffer_example_1 +/*`For all examples, we need this include: +*/ + +#include <boost/circular_buffer.hpp> + +//] [/circular_buffer_example_1] + + int main() + { + +//[circular_buffer_example_2 + // Create a circular buffer with a capacity for 3 integers. + boost::circular_buffer<int> cb(3); + + // Insert three elements into the buffer. + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + int a = cb[0]; // a == 1 + int b = cb[1]; // b == 2 + int c = cb[2]; // c == 3 + + // The buffer is full now, so pushing subsequent + // elements will overwrite the front-most elements. + + cb.push_back(4); // Overwrite 1 with 4. + cb.push_back(5); // Overwrite 2 with 5. + + // The buffer now contains 3, 4 and 5. + a = cb[0]; // a == 3 + b = cb[1]; // b == 4 + c = cb[2]; // c == 5 + + // Elements can be popped from either the front or the back. + cb.pop_back(); // 5 is removed. + cb.pop_front(); // 3 is removed. + + // Leaving only one element with value = 4. + int d = cb[0]; // d == 4 + +//] [/circular_buffer_example_2] + return 0; + } + + /* + + //[circular_buffer_example_output + +There is no output from this example. + +//] [/circular_buffer_example_output] + + */ + diff --git a/src/boost/libs/circular_buffer/example/circular_buffer_examples.bat b/src/boost/libs/circular_buffer/example/circular_buffer_examples.bat new file mode 100644 index 000000000..9f6c8f789 --- /dev/null +++ b/src/boost/libs/circular_buffer/example/circular_buffer_examples.bat @@ -0,0 +1,14 @@ +echo off +rem quickbook doxygen auto-index docs template circular_buffer_html_index.bat +rem echo circular_buffer_html_index_%date%_%time:~0,2%_%time:~3,2%.log +rem The DOS time format is assumed 12:34 and the : separator is not used. +set t=%time% /T +set tim=%t:~0,2%%t:~3,2% +rem pick just hours and minutes. +rem time may include leading space, like " 915", so remove space. +set tim=%tim: =% +rem boost-no-inspect +rem cd \boost-trunk/circular_buffer\libs\circular_buffer\example +bjam -a > circular_buffer_examples_%date%_%tim%.log +if not ERRORLEVEL 0 (echo Errorlevel is %ERRORLEVEL%) else (echo OK) +pause diff --git a/src/boost/libs/circular_buffer/example/circular_buffer_iter_example.cpp b/src/boost/libs/circular_buffer/example/circular_buffer_iter_example.cpp new file mode 100644 index 000000000..339d284fe --- /dev/null +++ b/src/boost/libs/circular_buffer/example/circular_buffer_iter_example.cpp @@ -0,0 +1,40 @@ +// Copyright 2003-2008 Jan Gaspar. +// Copyright 2013 Paul A. Bristow. Added some Quickbook snippet markers. + +// Distributed under the Boost Software License, Version 1.0. +// (See the accompanying file LICENSE_1_0.txt +// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.) + +#undef BOOST_CB_ENABLE_DEBUG + +//[circular_buffer_iter_example_1 +/*` +*/ + +#define BOOST_CB_ENABLE_DEBUG 0 // The Debug Support has to be disabled, otherwise the code produces a runtime error. + +#include <boost/circular_buffer.hpp> +#include <boost/assert.hpp> +#include <assert.h> + +int main(int /*argc*/, char* /*argv*/[]) +{ + + boost::circular_buffer<int> cb(3); + + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + boost::circular_buffer<int>::iterator it = cb.begin(); + + assert(*it == 1); + + cb.push_back(4); + + assert(*it == 4); // The iterator still points to the initialized memory. + + return 0; +} + +//] [/circular_buffer_iter_example_1] diff --git a/src/boost/libs/circular_buffer/example/circular_buffer_sum_example.cpp b/src/boost/libs/circular_buffer/example/circular_buffer_sum_example.cpp new file mode 100644 index 000000000..16f00174f --- /dev/null +++ b/src/boost/libs/circular_buffer/example/circular_buffer_sum_example.cpp @@ -0,0 +1,64 @@ +// Copyright 2003-2008 Jan Gaspar. +// Copyright 2013 Paul A. Bristow. Added some Quickbook snippet markers. + +// Distributed under the Boost Software License, Version 1.0. +// (See the accompanying file LICENSE_1_0.txt +// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.) + +//[circular_buffer_sum_example_1 + +/*`This example shows several functions, including summing all valid values. +*/ + + #include <boost/circular_buffer.hpp> + #include <numeric> + #include <assert.h> + + int main(int /*argc*/, char* /*argv*/[]) + { + // Create a circular buffer of capacity 3. + boost::circular_buffer<int> cb(3); + assert(cb.capacity() == 3); + // Check is empty. + assert(cb.size() == 0); + assert(cb.empty()); + + // Insert some elements into the circular buffer. + cb.push_back(1); + cb.push_back(2); + + // Assertions to check push_backs have expected effect. + assert(cb[0] == 1); + assert(cb[1] == 2); + assert(!cb.full()); + assert(cb.size() == 2); + assert(cb.capacity() == 3); + + // Insert some other elements. + cb.push_back(3); + cb.push_back(4); + + // Evaluate the sum of all elements. + int sum = std::accumulate(cb.begin(), cb.end(), 0); + + // Assertions to check state. + assert(sum == 9); + assert(cb[0] == 2); + assert(cb[1] == 3); + assert(cb[2] == 4); + assert(*cb.begin() == 2); + assert(cb.front() == 2); + assert(cb.back() == 4); + assert(cb.full()); + assert(cb.size() == 3); + assert(cb.capacity() == 3); + + return 0; + } + + //] [/circular_buffer_sum_example_1] + + + /* + There is no output from this example. + */ diff --git a/src/boost/libs/circular_buffer/example/jamfile.v2 b/src/boost/libs/circular_buffer/example/jamfile.v2 new file mode 100644 index 000000000..9a6e9e038 --- /dev/null +++ b/src/boost/libs/circular_buffer/example/jamfile.v2 @@ -0,0 +1,42 @@ +# Copyright Paul A. Bristow 2013 + +# Distributed under 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) + +# jamfile.v2 to run all circular_buffer examples. + +# bring in the rules for testing. +import testing ; + +project + : requirements + <library>/boost/system//boost_system + <library>/boost/thread//boost_thread + #<define>BOOST_ALL_NO_LIB=1 + <threading>multi + + <toolset>gcc:<cxxflags>-Wno-missing-braces + <toolset>darwin:<cxxflags>-Wno-missing-braces + <toolset>acc:<cxxflags>+W2068,2461,2236,4070 + <toolset>intel:<cxxflags>-Qwd264,239 + <toolset>msvc:<warnings>all + <toolset>msvc:<asynch-exceptions>on + <toolset>msvc:<define>_CRT_SECURE_NO_DEPRECATE + <toolset>msvc:<define>_SCL_SECURE_NO_DEPRECATE + <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS + <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS + <toolset>msvc:<cxxflags>/wd4996 + <toolset>msvc:<cxxflags>/wd4512 + <toolset>msvc:<cxxflags>/wd4610 + <toolset>msvc:<cxxflags>/wd4510 + <toolset>msvc:<cxxflags>/wd4127 + <toolset>msvc:<cxxflags>/wd4701 + <toolset>msvc:<cxxflags>/wd4127 + <toolset>msvc:<cxxflags>/wd4305 + ; + +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 ; + diff --git a/src/boost/libs/circular_buffer/index.html b/src/boost/libs/circular_buffer/index.html new file mode 100644 index 000000000..59018614f --- /dev/null +++ b/src/boost/libs/circular_buffer/index.html @@ -0,0 +1,25 @@ +<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" +"http://www.w3.org/TR/html4/loose.dtd"> +<html> + <head> + <meta http-equiv="refresh" content="0; URL=../../doc/html/circular_buffer.html"> + <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> + <title> + Redirection + </title> + </head> + <body> + Automatic redirection failed, please go to + <a href="../../doc/html/circular_buffer.html"> ../../doc/html/circular_buffer.html</a>. + <p> + <small>Copyright © 2003-2008 Jan Gaspar, 2013 Paul A. Bristow</small> + </p> + <p> + <small>Use, modification, and distribution is subject to the Boost Software License, Version 1.0.<br> + (See accompanying file <code>LICENSE_1_0.txt</code> or copy at <a href= + "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</small> + </p> + </body> +</html> + + diff --git a/src/boost/libs/circular_buffer/meta/libraries.json b/src/boost/libs/circular_buffer/meta/libraries.json new file mode 100644 index 000000000..b9f78c391 --- /dev/null +++ b/src/boost/libs/circular_buffer/meta/libraries.json @@ -0,0 +1,14 @@ +{ + "key": "circular_buffer", + "name": "Circular Buffer", + "authors": [ + "Jan Gaspar" + ], + "description": "A STL compliant container also known as ring or cyclic buffer.", + "category": [ + "Containers" + ], + "maintainers": [ + "Jan Gaspar <jano_gaspar -at- yahoo.com>" + ] +} diff --git a/src/boost/libs/circular_buffer/test/Jamfile.v2 b/src/boost/libs/circular_buffer/test/Jamfile.v2 new file mode 100644 index 000000000..7e1ae584e --- /dev/null +++ b/src/boost/libs/circular_buffer/test/Jamfile.v2 @@ -0,0 +1,32 @@ +# Boost circular_buffer test Jamfile. +# +# Copyright (c) 2003-2008 Jan Gaspar +# +# Distributed under 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) + +# Added warning suppression Paul A. Bristow 25 Nov 2008 + +# Bring in rules for testing. +import testing ; + +project + : requirements + <toolset>msvc:<warnings>all + <toolset>msvc:<asynch-exceptions>on + <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS + <toolset>msvc:<cxxflags>/wd4996 # 'function': was declared deprecated + <toolset>msvc:<cxxflags>/wd4244 # conversion from 'int' to 'unsigned short', possible loss of data + # in date-time + ; + +test-suite "circular_buffer" + : [ run base_test.cpp : : : <threading>single : ] + [ run space_optimized_test.cpp : : : <threading>single : ] + [ run base_test.cpp : : : <threading>single <define>"BOOST_CB_ENABLE_DEBUG=1" : base_test_dbg ] + [ run space_optimized_test.cpp : : : <threading>single <define>"BOOST_CB_ENABLE_DEBUG=1" : space_optimized_test_dbg ] + [ run soft_iterator_invalidation.cpp : : : <threading>single : ] + [ run constant_erase_test.cpp : : : <threading>single : ] + [ compile bounded_buffer_comparison.cpp : <threading>multi : ] + ; diff --git a/src/boost/libs/circular_buffer/test/base_test.cpp b/src/boost/libs/circular_buffer/test/base_test.cpp new file mode 100644 index 000000000..6f51871a9 --- /dev/null +++ b/src/boost/libs/circular_buffer/test/base_test.cpp @@ -0,0 +1,862 @@ +// Test of the base circular buffer container. + +// Copyright (c) 2003-2008 Jan Gaspar +// Copyright (c) 2013 Antony Polukhin + +// 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_TEST(itCopy == it); + BOOST_TEST(cit == it); + BOOST_TEST(end1 == end2); + BOOST_TEST(it != end1); + BOOST_TEST(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_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() { + + 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_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() { + + 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_TEST(it1 == cb.begin() + 1); + BOOST_TEST(it2 == cb.begin() + 6); + BOOST_TEST(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_TEST(it1 == cb.end() - 1); + BOOST_TEST(it2 == cb.end() - 6); + BOOST_TEST(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_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() { + + 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_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() { + + 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_TEST(it[0] == 2); + BOOST_TEST(it[-1] == 1); + BOOST_TEST(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_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() { + +#if BOOST_CB_ENABLE_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_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); + const circular_buffer<MyInteger> ccb(5, 0); + + it1 = cb.begin(); + it2 = ccb.begin(); + it3 = cb.end(); + it4 = it1; + it5 = it2; + it6 = it1; + + 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_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_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_TEST(i == 3); + + circular_buffer<MyInteger> cb1(10, 0); + circular_buffer<MyInteger> cb2(20, 0); + it1 = cb1.end(); + it2 = cb2.begin(); + BOOST_TEST(it1.is_valid(&cb1)); + BOOST_TEST(it2.is_valid(&cb2)); + + cb1.swap(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_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); + 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_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_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); + 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_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_TEST(it1.is_valid(&cb1)); + BOOST_TEST(!it2.is_valid(&cb1)); + + it1 = cb1.begin() + 5; + it2 = cb1.begin(); + cb1.pop_front(); + 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_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_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_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_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); + cb7.push_back(3); + cb7.push_back(4); + it1 = cb7.end(); + it2 = cb7.begin(); + it3 = cb7.begin() + 6; + cb7.linearize(); + 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_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); + it1 = cb7.end(); + it2 = cb7.begin(); + it3 = cb7.begin() + 6; + cb7.set_capacity(10); + BOOST_TEST(it1.is_valid(&cb7)); + BOOST_TEST(it2.is_valid(&cb7)); + BOOST_TEST(it3.is_valid(&cb7)); + cb7.set_capacity(20); + 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_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); + it1 = cb7.end(); + it2 = cb7.begin(); + it3 = cb7.begin() + 6; + cb7.rset_capacity(10); + BOOST_TEST(it1.is_valid(&cb7)); + BOOST_TEST(it2.is_valid(&cb7)); + BOOST_TEST(it3.is_valid(&cb7)); + cb7.rset_capacity(20); + 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_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); + cb8.push_back(3); + it1 = cb8.end(); + it2 = cb8.begin(); + it3 = cb8.begin() + 6; + cb8.resize(10); + BOOST_TEST(it1.is_valid(&cb8)); + BOOST_TEST(it2.is_valid(&cb8)); + BOOST_TEST(it3.is_valid(&cb8)); + cb8.resize(20); + 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_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); + cb8.push_back(6); + it1 = cb8.end(); + it2 = cb8.begin(); + it3 = cb8.begin() + 6; + cb8.rresize(10); + BOOST_TEST(it1.is_valid(&cb8)); + BOOST_TEST(it2.is_valid(&cb8)); + BOOST_TEST(it3.is_valid(&cb8)); + cb8.rresize(20); + 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_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(); + it2 = cb9.begin(); + it3 = cb9.begin() + 6; + it4 = cb9.begin() + 12; + cb9 = cb8; + 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(); + it2 = cb10.begin(); + it3 = cb10.begin() + 3; + it4 = cb10.begin() + 7; + cb10.assign(5, 2); + 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(); + it2 = cb11.begin(); + it3 = cb11.begin() + 3; + it4 = cb11.begin() + 7; + cb11.assign(15, 5, 2); + 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(); + it2 = cb12.begin(); + it3 = cb12.begin() + 3; + it4 = cb12.begin() + 7; + cb12.assign(cb11.begin(), cb11.end()); + 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(); + it2 = cb13.begin(); + it3 = cb13.begin() + 3; + it4 = cb13.begin() + 7; + cb13.assign(15, cb11.begin(), cb11.end()); + 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); + 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_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); + 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_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); + 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_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 +} + +// 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_TEST_THROWS(cb1.set_capacity(5), std::exception); + BOOST_TEST(cb1.capacity() == 3); + MyInteger::set_exception_trigger(3); + BOOST_TEST_THROWS(cb1.rset_capacity(5), std::exception); + BOOST_TEST(cb1.capacity() == 3); + generic_test(cb1); + + MyInteger::set_exception_trigger(3); + BOOST_TEST_THROWS(circular_buffer<MyInteger> cb2(5, 10), std::exception); + + circular_buffer<MyInteger> cb3(5, 10); + MyInteger::set_exception_trigger(3); + BOOST_TEST_THROWS(circular_buffer<MyInteger> cb4(cb3), std::exception); + + vector<MyInteger> v(5, MyInteger(10)); + MyInteger::set_exception_trigger(3); + 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_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_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_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_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_TEST_THROWS(cb11.rinsert(cb11.begin(), 1), std::exception); + + circular_buffer<MyInteger> cb12(5, 1); + MyInteger::set_exception_trigger(3); + BOOST_TEST_THROWS(cb12.assign(4, 2), std::exception); + + circular_buffer<MyInteger> cb13(5, 1); + MyInteger::set_exception_trigger(3); + 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_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_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_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_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_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_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_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_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_TEST_THROWS(cb22.insert(cb22.end(), 4), std::exception); + + circular_buffer<MyInteger> cb23(5, 0); + MyInteger::set_exception_trigger(2); + 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_TEST_THROWS(cb24.rinsert(cb24.begin() + 1, 4), std::exception); + + circular_buffer<MyInteger> cb25(5, 0); + MyInteger::set_exception_trigger(2); + 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_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_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_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_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_TEST_THROWS(cb30.rinsert(cb30.begin(), 10, 3), std::exception); + +#endif // #if !defined(BOOST_NO_EXCEPTIONS) +} + + +void move_container_values_except() { + move_container_values_impl<noncopyable_movable_except_t>(); +} + +template <class T> +void move_container_values_resetting_impl() { + typedef T noncopyable_movable_test_t; + CB_CONTAINER<noncopyable_movable_test_t> cb1(1); + noncopyable_movable_test_t var; + cb1.push_back(); + + cb1.push_back(boost::move(var)); + BOOST_TEST(!cb1.back().is_moved()); + BOOST_TEST(var.is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + BOOST_TEST(cb1.back().is_moved()); + + cb1.push_front(boost::move(var)); + BOOST_TEST(!cb1.front().is_moved()); + BOOST_TEST(var.is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + BOOST_TEST(cb1.back().is_moved()); + + cb1.push_back(); + BOOST_TEST(!cb1.back().is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + BOOST_TEST(cb1.back().is_moved()); + + cb1.push_front(); + BOOST_TEST(!cb1.front().is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + 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_TEST(cb1.front().is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + 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_TEST(cb1.front().is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + BOOST_TEST(cb1.back().is_moved()); + + cb1.rinsert(cb1.begin()); + BOOST_TEST(!cb1.back().is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + BOOST_TEST(cb1.back().is_moved()); + + var.reinit(); + cb1.rinsert(cb1.begin(), boost::move(var)); + BOOST_TEST(!cb1.back().is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + BOOST_TEST(cb1.back().is_moved()); + + cb1.rinsert(cb1.end()); + BOOST_TEST(cb1.back().is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + BOOST_TEST(cb1.back().is_moved()); + + var.reinit(); + cb1.rinsert(cb1.end(), boost::move(var)); + BOOST_TEST(cb1.back().is_moved()); + BOOST_TEST(cb1.size() == 1); + var = boost::move(cb1.back()); + BOOST_TEST(cb1.back().is_moved()); + cb1.push_back(); + BOOST_TEST(!cb1[0].is_moved()); + + const int val = cb1[0].value(); + cb1.linearize(); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(cb1[0].value() == val); + + cb1.rotate(cb1.begin()); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(cb1[0].value() == val); +} + +void move_container_values_resetting_except() { + move_container_values_resetting_impl<noncopyable_movable_except_t>(); +} + +void move_container_values_resetting_noexcept() { + move_container_values_resetting_impl<noncopyable_movable_noexcept_t>(); +} + +// test main +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(); +} diff --git a/src/boost/libs/circular_buffer/test/bounded_buffer_comparison.cpp b/src/boost/libs/circular_buffer/test/bounded_buffer_comparison.cpp new file mode 100644 index 000000000..c2bec05df --- /dev/null +++ b/src/boost/libs/circular_buffer/test/bounded_buffer_comparison.cpp @@ -0,0 +1,316 @@ +// Comparison of bounded buffers based on different containers. + +// Copyright (c) 2003-2008 Jan Gaspar +// Copyright 2013 Paul A. Bristow. Added some Quickbook snippet markers. + +// 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 <boost/circular_buffer.hpp> +#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/bind.hpp> +#include <deque> +#include <list> +#include <string> +#include <iostream> + +const unsigned long QUEUE_SIZE = 1000L; +const unsigned long TOTAL_ELEMENTS = QUEUE_SIZE * 1000L; + +template <class T> +class bounded_buffer { +public: + + typedef boost::circular_buffer<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer(size_type capacity) : m_unread(0), m_container(capacity) {} + + void push_front(param_type item) { + boost::unique_lock<boost::mutex> lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_full, this)); + m_container.push_front(item); + ++m_unread; + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::unique_lock<boost::mutex> lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_empty, this)); + *pItem = m_container[--m_unread]; + lock.unlock(); + m_not_full.notify_one(); + } + +private: + bounded_buffer(const bounded_buffer&); // Disabled copy constructor + bounded_buffer& operator = (const bounded_buffer&); // Disabled assign operator + + bool is_not_empty() const { return m_unread > 0; } + bool is_not_full() const { return m_unread < m_container.capacity(); } + + size_type m_unread; + container_type m_container; + boost::mutex m_mutex; + boost::condition_variable m_not_empty; + boost::condition_variable m_not_full; +}; + +template <class T> +class bounded_buffer_space_optimized { +public: + + typedef boost::circular_buffer_space_optimized<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer_space_optimized(size_type capacity) : m_container(capacity) {} + + void push_front(param_type item) { + boost::unique_lock<boost::mutex> lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer_space_optimized<value_type>::is_not_full, this)); + m_container.push_front(item); + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::unique_lock<boost::mutex> lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer_space_optimized<value_type>::is_not_empty, this)); + *pItem = m_container.back(); + m_container.pop_back(); + lock.unlock(); + m_not_full.notify_one(); + } + +private: + + bounded_buffer_space_optimized(const bounded_buffer_space_optimized&); // Disabled copy constructor + bounded_buffer_space_optimized& operator = (const bounded_buffer_space_optimized&); // Disabled assign operator + + bool is_not_empty() const { return m_container.size() > 0; } + bool is_not_full() const { return m_container.size() < m_container.capacity(); } + + container_type m_container; + boost::mutex m_mutex; + boost::condition_variable m_not_empty; + boost::condition_variable m_not_full; +}; + +template <class T> +class bounded_buffer_deque_based { +public: + + typedef std::deque<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer_deque_based(size_type capacity) : m_capacity(capacity) {} + + void push_front(param_type item) { + boost::unique_lock<boost::mutex> lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer_deque_based<value_type>::is_not_full, this)); + m_container.push_front(item); + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::unique_lock<boost::mutex> lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer_deque_based<value_type>::is_not_empty, this)); + *pItem = m_container.back(); + m_container.pop_back(); + lock.unlock(); + m_not_full.notify_one(); + } + +private: + + bounded_buffer_deque_based(const bounded_buffer_deque_based&); // Disabled copy constructor + bounded_buffer_deque_based& operator = (const bounded_buffer_deque_based&); // Disabled assign operator + + bool is_not_empty() const { return m_container.size() > 0; } + bool is_not_full() const { return m_container.size() < m_capacity; } + + const size_type m_capacity; + container_type m_container; + boost::mutex m_mutex; + boost::condition_variable m_not_empty; + boost::condition_variable m_not_full; +}; + +template <class T> +class bounded_buffer_list_based { +public: + + typedef std::list<T> container_type; + typedef typename container_type::size_type size_type; + typedef typename container_type::value_type value_type; + typedef typename boost::call_traits<value_type>::param_type param_type; + + explicit bounded_buffer_list_based(size_type capacity) : m_capacity(capacity) {} + + void push_front(param_type item) { + boost::unique_lock<boost::mutex> lock(m_mutex); + m_not_full.wait(lock, boost::bind(&bounded_buffer_list_based<value_type>::is_not_full, this)); + m_container.push_front(item); + lock.unlock(); + m_not_empty.notify_one(); + } + + void pop_back(value_type* pItem) { + boost::unique_lock<boost::mutex> lock(m_mutex); + m_not_empty.wait(lock, boost::bind(&bounded_buffer_list_based<value_type>::is_not_empty, this)); + *pItem = m_container.back(); + m_container.pop_back(); + lock.unlock(); + m_not_full.notify_one(); + } + +private: + + bounded_buffer_list_based(const bounded_buffer_list_based&); // Disabled copy constructor + bounded_buffer_list_based& operator = (const bounded_buffer_list_based&); // Disabled assign operator + + bool is_not_empty() const { return m_container.size() > 0; } + bool is_not_full() const { return m_container.size() < m_capacity; } + + const size_type m_capacity; + container_type m_container; + boost::mutex m_mutex; + boost::condition_variable m_not_empty; + boost::condition_variable m_not_full; +}; + +template<class Buffer> +class Consumer { + + typedef typename Buffer::value_type value_type; + Buffer* m_container; + value_type m_item; + +public: + Consumer(Buffer* buffer) : m_container(buffer) {} + + void operator()() { + for (unsigned long i = 0L; i < TOTAL_ELEMENTS; ++i) { + m_container->pop_back(&m_item); + } + } +}; + +template<class Buffer> +class Producer { + + typedef typename Buffer::value_type value_type; + Buffer* m_container; + +public: + Producer(Buffer* buffer) : m_container(buffer) {} + + void operator()() { + for (unsigned long i = 0L; i < TOTAL_ELEMENTS; ++i) { + m_container->push_front(value_type()); + } + } +}; + +template<class Buffer> +void fifo_test(Buffer* buffer) { + + // Start of measurement + 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) { +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + buffer->push_front(Buffer::value_type()); +#else + buffer->push_front(BOOST_DEDUCED_TYPENAME Buffer::value_type()); +#endif + } + + Consumer<Buffer> consumer(buffer); + Producer<Buffer> producer(buffer); + + // Start the threads. + boost::thread consume(consumer); + boost::thread produce(producer); + + // Wait for completion. + consume.join(); + produce.join(); + + // End of measurement +} + +int main(int /*argc*/, char* /*argv*/[]) { + + bounded_buffer<int> bb_int(QUEUE_SIZE); + std::cout << "bounded_buffer<int> "; + fifo_test(&bb_int); + + bounded_buffer_space_optimized<int> bb_space_optimized_int(QUEUE_SIZE); + std::cout << "bounded_buffer_space_optimized<int> "; + fifo_test(&bb_space_optimized_int); + + bounded_buffer_deque_based<int> bb_deque_based_int(QUEUE_SIZE); + std::cout << "bounded_buffer_deque_based<int> "; + fifo_test(&bb_deque_based_int); + + bounded_buffer_list_based<int> bb_list_based_int(QUEUE_SIZE); + std::cout << "bounded_buffer_list_based<int> "; + fifo_test(&bb_list_based_int); + + bounded_buffer<std::string> bb_string(QUEUE_SIZE); + std::cout << "bounded_buffer<std::string> "; + fifo_test(&bb_string); + + bounded_buffer_space_optimized<std::string> bb_space_optimized_string(QUEUE_SIZE); + std::cout << "bounded_buffer_space_optimized<std::string> "; + fifo_test(&bb_space_optimized_string); + + bounded_buffer_deque_based<std::string> bb_deque_based_string(QUEUE_SIZE); + std::cout << "bounded_buffer_deque_based<std::string> "; + fifo_test(&bb_deque_based_string); + + bounded_buffer_list_based<std::string> bb_list_based_string(QUEUE_SIZE); + std::cout << "bounded_buffer_list_based<std::string> "; + fifo_test(&bb_list_based_string); + + return 0; +} +/* + +//[bounded_buffer_comparison_output + + Description: Autorun "J:\Cpp\Misc\Debug\bounded_buffer_comparison.exe" + bounded_buffer<int> 5.15 s + + bounded_buffer_space_optimized<int> 5.71 s + + bounded_buffer_deque_based<int> 15.57 s + + bounded_buffer_list_based<int> 17.33 s + + bounded_buffer<std::string> 24.49 s + + bounded_buffer_space_optimized<std::string> 28.33 s + + bounded_buffer_deque_based<std::string> 29.45 s + + bounded_buffer_list_based<std::string> 31.29 s + + //] //[bounded_buffer_comparison_output] + +*/ diff --git a/src/boost/libs/circular_buffer/test/common.ipp b/src/boost/libs/circular_buffer/test/common.ipp new file mode 100644 index 000000000..69215549e --- /dev/null +++ b/src/boost/libs/circular_buffer/test/common.ipp @@ -0,0 +1,2497 @@ +// Common tests for the circular buffer and its adaptor. + +// Copyright (c) 2003-2008 Jan Gaspar +// Copyright (c) 2013 Antony Polukhin + +// Copyright 2014,2018 Glen Joseph Fernandes +// (glenjofe@gmail.com) + +// 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 <boost/type_traits/is_nothrow_move_constructible.hpp> +#include <boost/type_traits/is_nothrow_move_assignable.hpp> +#include <boost/type_traits/has_nothrow_constructor.hpp> + +template <class Alloc> +void generic_test(CB_CONTAINER<MyInteger, Alloc>& cb) { + + vector<int> v; + v.push_back(11); + v.push_back(12); + v.push_back(13); + v.push_back(14); + v.push_back(15); + v.push_back(16); + v.push_back(17); + + if (cb.capacity() == 0) { + + cb.insert(cb.begin(), 1); + cb.insert(cb.begin(), v.begin(), v.end()); + cb.rinsert(cb.end(), 2); + cb.rinsert(cb.end(), v.begin(), v.end()); + cb.push_back(3); + cb.push_front(4); + cb.linearize(); + + BOOST_TEST(cb.empty()); + BOOST_TEST(cb.full()); + + } else { + + cb.insert(cb.end(), 1); + BOOST_TEST(!cb.empty()); + BOOST_TEST(cb[cb.size() - 1] == 1); + + size_t size = cb.size(); + cb.rerase(cb.end() - 1, cb.end()); + BOOST_TEST(size == cb.size() + 1); + + cb.insert(cb.end(), v.begin(), v.end()); + BOOST_TEST(!cb.empty()); + BOOST_TEST(cb[cb.size() - 1] == 17); + + size = cb.size(); + cb.erase(cb.end() - 1, cb.end()); + BOOST_TEST(size == cb.size() + 1); + + size = cb.size(); + cb.rinsert(cb.begin(), 2); + BOOST_TEST(size + 1 == cb.size()); + BOOST_TEST(cb[0] == 2); + + size = cb.size(); + cb.erase(cb.begin()); + BOOST_TEST(size == cb.size() + 1); + + cb.rinsert(cb.begin(), v.begin(), v.end()); + BOOST_TEST(!cb.empty()); + BOOST_TEST(cb[0] == 11); + + size = cb.size(); + cb.pop_front(); + BOOST_TEST(size == cb.size() + 1); + + cb.push_back(3); + BOOST_TEST(!cb.empty()); + BOOST_TEST(cb[cb.size() - 1] == 3); + + size = cb.size(); + cb.pop_back(); + BOOST_TEST(size == cb.size() + 1); + + cb.push_front(4); + BOOST_TEST(!cb.empty()); + BOOST_TEST(cb[0] == 4); + + cb.linearize(); + BOOST_TEST(!cb.empty()); + BOOST_TEST(cb[0] == 4); + + size = cb.size(); + cb.rerase(cb.begin()); + BOOST_TEST(size == cb.size() + 1); + } +} + +void basic_test() { + + vector<int> v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + v.push_back(4); + v.push_back(5); + v.push_back(6); + v.push_back(7); + CB_CONTAINER<MyInteger> cb1(3, v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb3(7, v.begin(), v.end()); + + BOOST_TEST(cb1.full()); + BOOST_TEST(cb1.capacity() == 3); + BOOST_TEST(cb1.size() == 3); + BOOST_TEST(cb1[0] == 5); + BOOST_TEST(cb1[2] == 7); + BOOST_TEST(!cb2.full()); + BOOST_TEST(cb2[2] == 3); + BOOST_TEST(cb3.full()); + BOOST_TEST(cb3[0] == 1); + BOOST_TEST(cb3[6] == 7); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); +} + +void constructor_and_element_access_test() { + + CB_CONTAINER<int> cb(5, 3); + cb[1] = 10; + + BOOST_TEST(cb.full()); + BOOST_TEST(cb[1] == 10); + BOOST_TEST(cb[4] == 3); +} + +void size_test() { + + CB_CONTAINER<MyInteger> cb1(3); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + CB_CONTAINER<MyInteger> cb2(5); + + BOOST_TEST(cb1.size() == 3); + BOOST_TEST(cb2.size() == 0); + BOOST_TEST(cb1.max_size() == cb2.max_size()); + + generic_test(cb1); + generic_test(cb2); +} + +template<class T> +class my_allocator { +public: + typedef T value_type; + + + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + +private: + template<class U> + struct const_pointer_; + + template<class U> + struct pointer_ { + pointer_() : hidden_ptr_(0) {} + pointer_(void* p) : hidden_ptr_(static_cast<U*>(p)) {} + difference_type operator-(const const_pointer_<U>& rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; } + difference_type operator-(pointer_ rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; } + pointer_ operator-(size_type rhs) const { return hidden_ptr_ - rhs; } + bool operator == (pointer_ rhs) const { return hidden_ptr_ == rhs.hidden_ptr_; } + bool operator != (pointer_ rhs) const { return hidden_ptr_ != rhs.hidden_ptr_; } + bool operator < (pointer_ rhs) const { return hidden_ptr_ < rhs.hidden_ptr_; } + bool operator >= (pointer_ rhs) const { return hidden_ptr_ >= rhs.hidden_ptr_; } + pointer_& operator++() { ++hidden_ptr_; return *this; } + pointer_& operator--() { --hidden_ptr_; return *this; } + pointer_& operator+=(size_type s) { hidden_ptr_ += s; return *this; } + pointer_ operator+(size_type s) const { return hidden_ptr_ + s; } + pointer_ operator++(int) { pointer_ p = *this; ++hidden_ptr_; return p; } + pointer_ operator--(int) { pointer_ p = *this; --hidden_ptr_; return p; } + U& operator*() const { return *hidden_ptr_; } + U* operator->() const { return hidden_ptr_; } + + U* hidden_ptr_; + }; + + template<class U> + struct const_pointer_ { + const_pointer_() : hidden_ptr_(0) {} + const_pointer_(pointer_<U> p) : hidden_ptr_(p.hidden_ptr_) {} + const_pointer_(const void* p) : hidden_ptr_(static_cast<const U*>(p)) {} + difference_type operator-(pointer_<U> rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; } + difference_type operator-(const_pointer_ rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; } + const_pointer_ operator-(size_type rhs) const { return hidden_ptr_ - rhs; } + bool operator == (const_pointer_ rhs) const { return hidden_ptr_ == rhs.hidden_ptr_; } + bool operator != (const_pointer_ rhs) const { return hidden_ptr_ != rhs.hidden_ptr_; } + bool operator < (const_pointer_ rhs) const { return hidden_ptr_ < rhs.hidden_ptr_; } + bool operator >= (const_pointer_ rhs) const { return hidden_ptr_ >= rhs.hidden_ptr_; } + const_pointer_& operator++() { ++hidden_ptr_; return *this; } + const_pointer_& operator--() { --hidden_ptr_; return *this; } + const_pointer_& operator+=(size_type s) { hidden_ptr_ += s; return hidden_ptr_; } + const_pointer_ operator+(size_type s) const { return hidden_ptr_ + s; } + const_pointer_ operator++(int) { const_pointer_ p = *this; ++hidden_ptr_; return p; } + const_pointer_ operator--(int) { const_pointer_ p = *this; --hidden_ptr_; return p; } + const U& operator*() const { return *hidden_ptr_; } + + const U* hidden_ptr_; + }; + +public: + typedef pointer_<T> pointer; + typedef const_pointer_<T> const_pointer; + + template<class T2> + struct rebind + { + typedef my_allocator<T2> other; + }; + + pointer allocate(size_type count) { + return pointer(::operator new(count * sizeof(value_type))); + } + + void deallocate(const pointer& ptr, size_type) + { ::operator delete(ptr.hidden_ptr_); } + + template<class P> + void construct(value_type* ptr, BOOST_FWD_REF(P) p) + { ::new((void*)ptr) value_type(::boost::forward<P>(p)); } + + void destroy(value_type* ptr) + { ptr->~value_type(); } + + size_type max_size() const { + return ~static_cast<size_type>(0) / sizeof(size_type); + } +}; + +void allocator_test() { + + CB_CONTAINER<MyInteger> cb1(10, 0); + const CB_CONTAINER<MyInteger> cb2(10, 0); + CB_CONTAINER<MyInteger>::allocator_type& alloc_ref = cb1.get_allocator(); + CB_CONTAINER<MyInteger>::allocator_type alloc = cb2.get_allocator(); + alloc_ref.max_size(); + alloc.max_size(); + + generic_test(cb1); + + + CB_CONTAINER<MyInteger, my_allocator<MyInteger> > cb_a(10, 0); + generic_test(cb_a); +} + +#if !defined(BOOST_CB_NO_CXX11_ALLOCATOR) +template<class T> +class cxx11_allocator { +public: + typedef T value_type; + + cxx11_allocator() { + } + + template<class U> + cxx11_allocator(const cxx11_allocator<U> &) { + } + + T* allocate(std::size_t n) { + return static_cast<T*>(::operator new(n * sizeof(T))); + } + + void deallocate(T * p, std::size_t n) { + ::operator delete( p ); + } +}; + +void cxx11_allocator_test() { + CB_CONTAINER<MyInteger, cxx11_allocator<MyInteger> > cb(10, 0); + generic_test(cb); +} +#endif + +void begin_and_end_test() { + + vector<int> v; + v.push_back(11); + v.push_back(12); + v.push_back(13); + + CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.end()); + const CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end()); + + CB_CONTAINER<MyInteger> cb3(10); + cb3.push_back(1); + cb3.push_back(2); + cb3.insert(cb3.begin(), 3); + int i = 0; + CB_CONTAINER<MyInteger>::const_iterator it = cb3.begin(); + for (; it != cb3.end(); it++) { + i += *it; + } + CB_CONTAINER<MyInteger> cb4(20); + const CB_CONTAINER<MyInteger> cb5(20); + + BOOST_TEST(*cb1.begin() == 11); + BOOST_TEST(*cb2.begin() == 11); + BOOST_TEST(i == 6); + BOOST_TEST(cb4.begin() == cb4.end()); + BOOST_TEST(cb5.begin() == cb5.end()); + + generic_test(cb1); + generic_test(cb3); + generic_test(cb4); +} + +void rbegin_and_rend_test() { + + vector<int> v; + v.push_back(11); + v.push_back(12); + v.push_back(13); + + CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.end()); + const CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end()); + + CB_CONTAINER<MyInteger> cb3(3); + cb3.push_back(1); + cb3.push_back(2); + cb3.insert(cb3.begin(), 3); + cb3.push_back(1); + int i = 0; + CB_CONTAINER<MyInteger>::reverse_iterator it = cb3.rbegin(); + for (; it != cb3.rend(); it++) { + i += *it; + } + CB_CONTAINER<MyInteger> cb4(20); + const CB_CONTAINER<MyInteger> cb5(20); + + BOOST_TEST(*cb1.rbegin() == 13); + BOOST_TEST(*cb2.rbegin() == 13); + BOOST_TEST(i == 4); + BOOST_TEST(cb4.rbegin() == cb4.rend()); + BOOST_TEST(cb5.rbegin() == cb5.rend()); + + generic_test(cb1); + generic_test(cb3); + generic_test(cb4); +} + +void element_access_and_insert_test() { + + CB_CONTAINER<MyInteger> cb(3); + cb.push_back(1); + cb.push_back(2); + cb.insert(cb.begin(), 3); + cb.push_back(4); + const CB_CONTAINER<MyInteger> ccb = cb; + + BOOST_TEST(cb[0] == 1); + BOOST_TEST(cb[1] == 2); + BOOST_TEST(cb[2] == 4); + BOOST_TEST(ccb[2] == 4); + + generic_test(cb); +} + +void at_test() { + +#if !defined(BOOST_NO_EXCEPTIONS) + + CB_CONTAINER<MyInteger> cb(3); + cb.push_back(1); + + try { + BOOST_TEST(cb.at(0) == 1); + } + catch (out_of_range&) { + BOOST_ERROR("An unexpected exception has been thrown!"); + } + + BOOST_TEST_THROWS(cb.at(2), out_of_range); + + generic_test(cb); + +#endif // #if !defined(BOOST_NO_EXCEPTIONS) +} + +void front_and_back_test() { + + CB_CONTAINER<MyInteger> cb(1); + cb.push_back(2); + cb.push_back(3); + + BOOST_TEST(cb.front() == cb.back()); + BOOST_TEST(cb.back() == 3); + + generic_test(cb); +} + +void linearize_test() { + + vector<int> v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + v.push_back(4); + v.push_back(5); + v.push_back(6); + v.push_back(7); + v.push_back(8); + v.push_back(9); + v.push_back(10); + v.push_back(11); + v.push_back(12); + CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.begin() + 10); + cb1.push_back(11); + cb1.push_back(12); + cb1.push_back(13); + CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.begin() + 10); + cb2.push_back(11); + cb2.push_back(12); + cb2.push_back(13); + cb2.push_back(14); + cb2.push_back(15); + cb2.push_back(16); + cb2.push_back(17); + CB_CONTAINER<MyInteger> cb3(10, v.begin(), v.begin() + 10); + cb3.push_back(11); + cb3.push_back(12); + cb3.push_back(13); + cb3.pop_front(); + cb3.pop_front(); + CB_CONTAINER<MyInteger> cb4(5); + CB_CONTAINER<MyInteger> cb5(12, v.begin(), v.end()); + cb5.push_back(13); + cb5.push_back(14); + cb5.push_back(15); + cb5.pop_front(); + cb5.pop_front(); + cb5.pop_front(); + cb5.pop_front(); + cb5.pop_front(); + cb5.pop_front(); + CB_CONTAINER<MyInteger> cb6(6); + cb6.push_back(-2); + cb6.push_back(-1); + cb6.push_back(0); + cb6.push_back(1); + cb6.push_back(2); + cb6.push_back(3); + cb6.push_back(4); + cb6.push_back(5); + cb6.push_back(6); + cb6.pop_back(); + CB_CONTAINER<MyInteger> cb7(6); + cb7.push_back(0); + cb7.push_back(1); + cb7.push_back(2); + cb7.push_back(3); + cb7.push_back(4); + + BOOST_TEST(!cb1.is_linearized()); + BOOST_TEST(*cb1.linearize() == 4); + BOOST_TEST(cb1.is_linearized()); + BOOST_TEST(cb1.linearize() == cb1.array_one().first); + BOOST_TEST(&cb1[0] < &cb1[1] + && &cb1[1] < &cb1[2] + && &cb1[2] < &cb1[3] + && &cb1[3] < &cb1[4] + && &cb1[4] < &cb1[5] + && &cb1[5] < &cb1[6] + && &cb1[6] < &cb1[7] + && &cb1[7] < &cb1[8] + && &cb1[8] < &cb1[9]); + BOOST_TEST(*(cb1.linearize() + 1) == 5); + BOOST_TEST(*(cb1.linearize() + 2) == 6); + BOOST_TEST(*(cb1.linearize() + 3) == 7); + BOOST_TEST(*(cb1.linearize() + 4) == 8); + BOOST_TEST(*(cb1.linearize() + 5) == 9); + BOOST_TEST(*(cb1.linearize() + 6) == 10); + BOOST_TEST(*(cb1.linearize() + 7) == 11); + BOOST_TEST(*(cb1.linearize() + 8) == 12); + BOOST_TEST(*(cb1.linearize() + 9) == 13); + BOOST_TEST(!cb2.is_linearized()); + BOOST_TEST(*cb2.linearize() == 8); + BOOST_TEST(cb2.is_linearized()); + BOOST_TEST(&cb2[0] < &cb2[1] + && &cb2[1] < &cb2[2] + && &cb2[2] < &cb2[3] + && &cb2[3] < &cb2[4] + && &cb2[4] < &cb2[5] + && &cb2[5] < &cb2[6] + && &cb2[6] < &cb2[7] + && &cb2[7] < &cb2[8] + && &cb2[8] < &cb2[9]); + BOOST_TEST(*(cb2.linearize() + 1) == 9); + BOOST_TEST(*(cb2.linearize() + 2) == 10); + BOOST_TEST(*(cb2.linearize() + 3) == 11); + BOOST_TEST(*(cb2.linearize() + 4) == 12); + BOOST_TEST(*(cb2.linearize() + 5) == 13); + BOOST_TEST(*(cb2.linearize() + 6) == 14); + BOOST_TEST(*(cb2.linearize() + 7) == 15); + BOOST_TEST(*(cb2.linearize() + 8) == 16); + BOOST_TEST(*(cb2.linearize() + 9) == 17); + BOOST_TEST(cb2.is_linearized()); + BOOST_TEST(*cb3.linearize() == 6); + BOOST_TEST(cb3.is_linearized()); + BOOST_TEST(&cb3[0] < &cb3[1] + && &cb3[1] < &cb3[2] + && &cb3[2] < &cb3[3] + && &cb3[3] < &cb3[4] + && &cb3[4] < &cb3[5] + && &cb3[5] < &cb3[6] + && &cb3[6] < &cb3[7]); + BOOST_TEST(*(cb3.linearize() + 1) == 7); + BOOST_TEST(*(cb3.linearize() + 2) == 8); + BOOST_TEST(*(cb3.linearize() + 3) == 9); + BOOST_TEST(*(cb3.linearize() + 4) == 10); + BOOST_TEST(*(cb3.linearize() + 5) == 11); + BOOST_TEST(*(cb3.linearize() + 6) == 12); + BOOST_TEST(*(cb3.linearize() + 7) == 13); + BOOST_TEST(cb4.linearize() == 0); + BOOST_TEST(cb4.is_linearized()); + BOOST_TEST(*cb5.linearize() == 10); + BOOST_TEST(cb5.is_linearized()); + BOOST_TEST(&cb5[0] < &cb5[1] + && &cb5[1] < &cb5[2] + && &cb5[2] < &cb5[3] + && &cb5[3] < &cb5[4] + && &cb5[4] < &cb5[5]); + BOOST_TEST(*(cb5.linearize() + 1) == 11); + BOOST_TEST(*(cb5.linearize() + 2) == 12); + BOOST_TEST(*(cb5.linearize() + 3) == 13); + BOOST_TEST(*(cb5.linearize() + 4) == 14); + BOOST_TEST(*(cb5.linearize() + 5) == 15); + BOOST_TEST(*cb6.linearize() == 1); + BOOST_TEST(cb6.is_linearized()); + BOOST_TEST(&cb6[0] < &cb6[1] + && &cb6[1] < &cb6[2] + && &cb6[2] < &cb6[3] + && &cb6[3] < &cb6[4]); + BOOST_TEST(*(cb6.linearize() + 1) == 2); + BOOST_TEST(*(cb6.linearize() + 2) == 3); + BOOST_TEST(*(cb6.linearize() + 3) == 4); + BOOST_TEST(*(cb6.linearize() + 4) == 5); + BOOST_TEST(cb7.is_linearized()); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); + generic_test(cb5); + generic_test(cb6); + generic_test(cb7); +} + +void array_range_test() { + + CB_CONTAINER<MyInteger> cb(7); + CB_CONTAINER<MyInteger>::array_range a1 = cb.array_one(); + CB_CONTAINER<MyInteger>::array_range a2 = cb.array_two(); + CB_CONTAINER<MyInteger>::const_array_range ca1 = cb.array_one(); + CB_CONTAINER<MyInteger>::const_array_range ca2 = cb.array_two(); + + BOOST_TEST(a1.second == 0); + BOOST_TEST(a2.second == 0); + BOOST_TEST(ca1.second == 0); + BOOST_TEST(ca2.second == 0); + + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + a1 = cb.array_one(); + a2 = cb.array_two(); + ca1 = cb.array_one(); + ca2 = cb.array_two(); + + BOOST_TEST(a1.first[0] == 1); + BOOST_TEST(a1.first[2] == 3); + BOOST_TEST(ca1.first[0] == 1); + BOOST_TEST(ca1.first[2] == 3); + BOOST_TEST(a1.second == 3); + BOOST_TEST(a2.second == 0); + BOOST_TEST(ca1.second == 3); + BOOST_TEST(ca2.second == 0); + + cb.push_back(4); + cb.push_back(5); + cb.push_back(6); + cb.push_back(7); + cb.push_back(8); + cb.push_back(9); + cb.push_back(10); + a1 = cb.array_one(); + a2 = cb.array_two(); + ca1 = cb.array_one(); + ca2 = cb.array_two(); + + BOOST_TEST(a1.first[0] == 4); + BOOST_TEST(a1.first[3] == 7); + BOOST_TEST(a2.first[0] == 8); + BOOST_TEST(a2.first[2] == 10); + BOOST_TEST(ca1.first[0] == 4); + BOOST_TEST(ca1.first[3] == 7); + BOOST_TEST(ca2.first[0] == 8); + BOOST_TEST(ca2.first[2] == 10); + BOOST_TEST(a1.second == 4); + BOOST_TEST(a2.second == 3); + BOOST_TEST(ca1.second == 4); + BOOST_TEST(ca2.second == 3); + + cb.pop_front(); + cb.pop_back(); + a1 = cb.array_one(); + a2 = cb.array_two(); + ca1 = cb.array_one(); + ca2 = cb.array_two(); + + BOOST_TEST(a1.first[0] == 5); + BOOST_TEST(a1.first[2] == 7); + BOOST_TEST(a2.first[0] == 8); + BOOST_TEST(a2.first[1] == 9); + BOOST_TEST(ca1.first[0] == 5); + BOOST_TEST(ca1.first[2] == 7); + BOOST_TEST(ca2.first[0] == 8); + BOOST_TEST(ca2.first[1] == 9); + BOOST_TEST(a1.second == 3); + BOOST_TEST(a2.second == 2); + BOOST_TEST(ca1.second == 3); + BOOST_TEST(ca2.second == 2); + + cb.pop_back(); + cb.pop_back(); + cb.pop_back(); + a1 = cb.array_one(); + a2 = cb.array_two(); + ca1 = cb.array_one(); + ca2 = cb.array_two(); + + BOOST_TEST(a1.first[0] == 5); + BOOST_TEST(a1.first[1] == 6); + BOOST_TEST(ca1.first[0] == 5); + BOOST_TEST(ca1.first[1] == 6); + BOOST_TEST(a1.second == 2); + BOOST_TEST(a2.second == 0); + BOOST_TEST(ca1.second == 2); + BOOST_TEST(ca2.second == 0); + + CB_CONTAINER<MyInteger> cb0(0); + a1 = cb0.array_one(); + a2 = cb0.array_two(); + + BOOST_TEST(a1.second == 0); + BOOST_TEST(a2.second == 0); + + const CB_CONTAINER<MyInteger> ccb(10, 1); + ca1 = ccb.array_one(); + ca2 = ccb.array_two(); + + BOOST_TEST(ca1.second == 10); + BOOST_TEST(*(ca1.first) == 1); + BOOST_TEST(ca2.second == 0); + + generic_test(cb); + generic_test(cb0); +} + +void capacity_and_reserve_test() { + + CB_CONTAINER<MyInteger> cb1(0); + CB_CONTAINER<MyInteger> cb2(10); + + BOOST_TEST(cb1.capacity() == 0); + BOOST_TEST(cb1.size() == 0); + BOOST_TEST(cb1.reserve() == 0); + BOOST_TEST(cb1.full()); + BOOST_TEST(cb1.empty()); + BOOST_TEST(cb1.reserve() == cb1.capacity() - cb1.size()); + BOOST_TEST(cb2.capacity() == 10); + BOOST_TEST(cb2.size() == 0); + BOOST_TEST(cb2.reserve() == 10); + BOOST_TEST(cb2.reserve() == cb2.capacity() - cb2.size()); + + cb1.push_back(1); + cb2.push_back(2); + cb2.push_back(2); + cb2.push_back(2); + + BOOST_TEST(cb1.capacity() == 0); + BOOST_TEST(cb1.size() == 0); + BOOST_TEST(cb1.reserve() == 0); + BOOST_TEST(cb1.full()); + BOOST_TEST(cb1.empty()); + BOOST_TEST(cb1.reserve() == cb1.capacity() - cb1.size()); + BOOST_TEST(cb2.capacity() == 10); + BOOST_TEST(cb2.size() == 3); + BOOST_TEST(cb2.reserve() == 7); + BOOST_TEST(cb2.reserve() == cb2.capacity() - cb2.size()); + + generic_test(cb1); + generic_test(cb2); +} + +void full_and_empty_test() { + + CB_CONTAINER<MyInteger> cb1(10); + CB_CONTAINER<MyInteger> cb2(3); + CB_CONTAINER<MyInteger> cb3(2); + CB_CONTAINER<MyInteger> cb4(2); + cb2.push_back(1); + cb2.push_back(3); + cb2.push_back(1); + cb2.push_back(1); + cb2.push_back(1); + cb3.push_back(3); + cb3.push_back(1); + cb4.push_back(1); + + BOOST_TEST(cb1.empty()); + BOOST_TEST(cb2.full()); + BOOST_TEST(cb3.full()); + BOOST_TEST(!cb4.empty()); + BOOST_TEST(!cb4.full()); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); +} + +void set_capacity_test() { + + CB_CONTAINER<MyInteger> cb1(10); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(1); + cb1.set_capacity(5); + CB_CONTAINER<MyInteger> cb2(3); + cb2.push_back(2); + cb2.push_back(3); + cb2.push_back(1); + cb2.set_capacity(10); + CB_CONTAINER<MyInteger> cb3(5); + cb3.push_back(2); + cb3.push_back(3); + cb3.push_back(1); + cb3.set_capacity(2); + + BOOST_TEST(cb1.size() == 3); + BOOST_TEST(cb1[0] == 2); + BOOST_TEST(cb1[2] == 1); + BOOST_TEST(cb1.capacity() == 5); + BOOST_TEST(cb2.size() == 3); + BOOST_TEST(cb2[0] == 2); + BOOST_TEST(cb2[2] == 1); + BOOST_TEST(cb2.capacity() == 10); + BOOST_TEST(cb3.size() == 2); + BOOST_TEST(cb3[0] == 2); + BOOST_TEST(cb3[1] == 3); + BOOST_TEST(cb3.capacity() == 2); + + cb3.set_capacity(2); + + BOOST_TEST(cb3.size() == 2); + BOOST_TEST(cb3[0] == 2); + BOOST_TEST(cb3[1] == 3); + BOOST_TEST(cb3.capacity() == 2); + + cb3.set_capacity(0); + + BOOST_TEST(cb3.size() == 0); + BOOST_TEST(cb3.capacity() == 0); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); +} + +void rset_capacity_test() { + + CB_CONTAINER<MyInteger> cb1(10); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(1); + cb1.rset_capacity(5); + CB_CONTAINER<MyInteger> cb2(3); + cb2.push_back(2); + cb2.push_back(3); + cb2.push_back(1); + cb2.rset_capacity(10); + CB_CONTAINER<MyInteger> cb3(5); + cb3.push_back(2); + cb3.push_back(3); + cb3.push_back(1); + cb3.rset_capacity(2); + + BOOST_TEST(cb1.size() == 3); + BOOST_TEST(cb1[0] == 2); + BOOST_TEST(cb1[2] == 1); + BOOST_TEST(cb1.capacity() == 5); + BOOST_TEST(cb2.size() == 3); + BOOST_TEST(cb2[0] == 2); + BOOST_TEST(cb2[2] == 1); + BOOST_TEST(cb2.capacity() == 10); + BOOST_TEST(cb3.size() == 2); + BOOST_TEST(cb3[0] == 3); + BOOST_TEST(cb3[1] == 1); + BOOST_TEST(cb3.capacity() == 2); + + cb3.rset_capacity(2); + + BOOST_TEST(cb3.size() == 2); + BOOST_TEST(cb3[0] == 3); + BOOST_TEST(cb3[1] == 1); + BOOST_TEST(cb3.capacity() == 2); + + cb3.rset_capacity(0); + + BOOST_TEST(cb3.size() == 0); + BOOST_TEST(cb3.capacity() == 0); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); +} + +void resize_test() { + + CB_CONTAINER<MyInteger> cb1(10); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.resize(20, 5); + CB_CONTAINER<MyInteger> cb2(10); + cb2.push_back(1); + cb2.push_back(2); + cb2.push_back(3); + cb2.push_back(4); + cb2.resize(2); + CB_CONTAINER<MyInteger> cb3(10, 1); + cb3.resize(0); + CB_CONTAINER<MyInteger> cb4(10, 1); + cb4.resize(10); + + BOOST_TEST(cb1.size() == 20); + BOOST_TEST(cb1.capacity() == 20); + BOOST_TEST(cb1[0] == 1); + BOOST_TEST(cb1[3] == 4); + BOOST_TEST(cb1[4] == 5); + BOOST_TEST(cb1[19] == 5); + BOOST_TEST(cb2.size() == 2); + BOOST_TEST(cb2.capacity() == 10); + BOOST_TEST(cb2[0] == 1); + BOOST_TEST(cb2[1] == 2); + BOOST_TEST(cb3.size() == 0); + BOOST_TEST(cb3.capacity() == 10); + BOOST_TEST(cb4.size() == 10); + BOOST_TEST(cb4.capacity() == 10); + BOOST_TEST(cb4[0] == 1); + BOOST_TEST(cb4[9] == 1); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); +} + +void rresize_test() { + + CB_CONTAINER<MyInteger> cb1(10); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.rresize(20, 5); + CB_CONTAINER<MyInteger> cb2(10); + cb2.push_back(1); + cb2.push_back(2); + cb2.push_back(3); + cb2.push_back(4); + cb2.rresize(2); + CB_CONTAINER<MyInteger> cb3(10, 1); + cb3.rresize(0); + CB_CONTAINER<MyInteger> cb4(10, 1); + cb4.rresize(10); + + BOOST_TEST(cb1.size() == 20); + BOOST_TEST(cb1.capacity() == 20); + BOOST_TEST(cb1[0] == 5); + BOOST_TEST(cb1[15] == 5); + BOOST_TEST(cb1[16] == 1); + BOOST_TEST(cb1[19] == 4); + BOOST_TEST(cb2.size() == 2); + BOOST_TEST(cb2.capacity() == 10); + BOOST_TEST(cb2[0] == 3); + BOOST_TEST(cb2[1] == 4); + BOOST_TEST(cb3.size() == 0); + BOOST_TEST(cb3.capacity() == 10); + BOOST_TEST(cb4.size() == 10); + BOOST_TEST(cb4.capacity() == 10); + BOOST_TEST(cb4[0] == 1); + BOOST_TEST(cb4[9] == 1); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); +} + +void constructor_test() { + + CB_CONTAINER<MyInteger> cb0; + BOOST_TEST(cb0.capacity() == 0); + BOOST_TEST(cb0.size() == 0); + + cb0.push_back(1); + cb0.push_back(2); + cb0.push_back(3); + + BOOST_TEST(cb0.size() == 0); + BOOST_TEST(cb0.capacity() == 0); + + CB_CONTAINER<MyInteger> cb1(3); + CB_CONTAINER<MyInteger> cb2(3, 2); + vector<int> v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + v.push_back(4); + v.push_back(5); + CB_CONTAINER<MyInteger> cb3(v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb4(3, v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb5(10, v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb6(10, 3, MyInteger(2)); + + BOOST_TEST(cb1.size() == 0); + BOOST_TEST(cb1.capacity() == 3); + BOOST_TEST(cb2[0] == 2); + BOOST_TEST(cb2.full()); + BOOST_TEST(cb2[0] == 2); + BOOST_TEST(cb2[1] == 2); + BOOST_TEST(cb2[2] == 2); + BOOST_TEST(cb3.size() == 5); + BOOST_TEST(cb3.capacity() == 5); + BOOST_TEST(cb3.full()); + BOOST_TEST(cb3[0] == 1); + BOOST_TEST(cb3[4] == 5); + BOOST_TEST(cb4.size() == 3); + BOOST_TEST(cb4.capacity() == 3); + BOOST_TEST(cb4.full()); + BOOST_TEST(cb4[0] == 3); + BOOST_TEST(cb4[2] == 5); + BOOST_TEST(cb5.size() == 5); + BOOST_TEST(cb5.capacity() == 10); + BOOST_TEST(!cb5.full()); + BOOST_TEST(cb5[0] == 1); + BOOST_TEST(cb5[4] == 5); + BOOST_TEST(cb6.size() == 3); + BOOST_TEST(cb6.capacity() == 10); + BOOST_TEST(!cb6.full()); + BOOST_TEST(cb6[0] == 2); + BOOST_TEST(cb6[2] == 2); + + cb5.push_back(6); + cb6.push_back(6); + + BOOST_TEST(cb5[5] == 6); + BOOST_TEST(cb5[0] == 1); + BOOST_TEST(cb5.size() == 6); + BOOST_TEST(cb6[3] == 6); + BOOST_TEST(cb6.size() == 4); + BOOST_TEST(cb6[0] == 2); + +#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + + CB_CONTAINER<int> cb7(MyInputIterator(v.begin()), MyInputIterator(v.end())); + CB_CONTAINER<int> cb8(3, MyInputIterator(v.begin()), MyInputIterator(v.end())); + + BOOST_TEST(cb7.capacity() == 5); + BOOST_TEST(cb8.capacity() == 3); + +#endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); + generic_test(cb5); + generic_test(cb6); +} + +void assign_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.push_back(5); + cb1.assign(3, 8); + BOOST_TEST(cb1.size() == 3); + BOOST_TEST(cb1.capacity() == 3); + BOOST_TEST(cb1[0] == 8); + BOOST_TEST(cb1[2] == 8); + + cb1.assign(6, 7); + BOOST_TEST(cb1.size() == 6); + BOOST_TEST(cb1.capacity() == 6); + BOOST_TEST(cb1[0] == 7); + BOOST_TEST(cb1[5] == 7); + + CB_CONTAINER<float> cb2(4); + cb2.assign(3, 1.1f); + BOOST_TEST(cb2[0] == 1.1f); + + CB_CONTAINER<MyInteger> cb3(5); + cb3.push_back(1); + cb3.push_back(2); + cb3.push_back(3); + cb3.assign((size_t)10, 1); // The size_t cast is not needed. It is present here just because of testing purposes. + BOOST_TEST(cb3[0] == 1); + BOOST_TEST(cb3[9] == 1); + BOOST_TEST(cb3.size() == 10); + BOOST_TEST(cb3.capacity() == 10); + +#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + + vector<int> v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + v.push_back(4); + v.push_back(5); + + CB_CONTAINER<int> cb4(3); + cb4.assign(MyInputIterator(v.begin()), MyInputIterator(v.end())); + CB_CONTAINER<int> cb5(3); + cb5.assign(4, MyInputIterator(v.begin()), MyInputIterator(v.end())); + + BOOST_TEST(cb4.capacity() == 5); + BOOST_TEST(cb5.capacity() == 4); + +#endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + + generic_test(cb1); + generic_test(cb3); +} + +void copy_constructor_and_assign_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.push_back(5); + CB_CONTAINER<MyInteger> cb2 = cb1; + + BOOST_TEST(cb1 == cb2); + BOOST_TEST(cb2.capacity() == 4); + BOOST_TEST(cb2[0] == 2); + BOOST_TEST(cb2[3] == 5); + + CB_CONTAINER<MyInteger> cb3(20); + cb1.pop_back(); + CB_CONTAINER<MyInteger> cb4(3); + cb3 = cb2; + cb3 = cb3; + cb4 = cb1; + CB_CONTAINER<MyInteger> cb5 = cb1; + + BOOST_TEST(cb3 == cb2); + BOOST_TEST(cb4 == cb1); + BOOST_TEST(cb2.full()); + BOOST_TEST(cb2[0] == 2); + BOOST_TEST(cb3.full()); + BOOST_TEST(cb3.capacity() == 4); + BOOST_TEST(cb4.capacity() == 4); + BOOST_TEST(!cb4.full()); + BOOST_TEST(*(cb4.end() - 1) == 4); + BOOST_TEST(cb1 == cb5); + BOOST_TEST(cb5.capacity() == 4); + BOOST_TEST(cb2[0] == 2); + BOOST_TEST(cb2[2] == 4); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); + generic_test(cb5); +} + +void swap_test() { + + CB_CONTAINER<MyInteger> cb1(2); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + CB_CONTAINER<MyInteger> cb2(5); + cb2.push_back(8); + cb2.swap(cb1); + cb2.swap(cb2); + + BOOST_TEST(cb2.capacity() == 2); + BOOST_TEST(cb2[0] == 2); + BOOST_TEST(cb2.full()); + BOOST_TEST(cb1.capacity() == 5); + BOOST_TEST(cb1[0] == 8); + BOOST_TEST(cb1.size() == 1); + + generic_test(cb1); + generic_test(cb2); +} + +void push_back_test() { + + CB_CONTAINER<MyDefaultConstructible> cb1(5); + cb1.push_back(); + cb1.push_back(MyDefaultConstructible(2)); + BOOST_TEST(cb1[0].m_n == 1); + BOOST_TEST(cb1[1].m_n == 2); + + CB_CONTAINER<MyInteger> cb2(5); + cb2.push_back(); + BOOST_TEST(cb2.back() == CB_CONTAINER<MyInteger>::value_type()); + + cb2.push_back(1); + BOOST_TEST(cb2.back() == 1); + + generic_test(cb2); +} + +void pop_back_test() { + + CB_CONTAINER<MyInteger> cb(4); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + cb.push_back(4); + cb.push_back(5); + cb.pop_back(); + + BOOST_TEST(cb.size() == 3); + BOOST_TEST(!cb.full()); + BOOST_TEST(cb[0] == 2); + + generic_test(cb); +} + +void insert_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1; + it1 = cb1.insert(it1, 10); + CB_CONTAINER<MyInteger> cb2(4); + cb2.push_back(1); + cb2.insert(cb2.begin()); + cb2.insert(cb2.begin(), -1); + CB_CONTAINER<MyInteger>::iterator it2 = cb2.begin() + 1; + it2 = cb2.insert(it2, 5); + CB_CONTAINER<MyInteger> cb3(2); + cb3.insert(cb3.end(), 10); + cb3.insert(cb3.end(), 20); + cb3.insert(cb3.begin(), 30); + cb3.insert(cb3.end(), 40); + + BOOST_TEST(cb1[1] == 10); + BOOST_TEST(*it1 == 10); + BOOST_TEST(cb1.full()); + BOOST_TEST(cb2[1] == 5); + BOOST_TEST(*it2 == 5); + BOOST_TEST(cb2.full()); + BOOST_TEST(cb3[0] == 20); + BOOST_TEST(cb3[1] == 40); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); +} + +void insert_n_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.insert(cb1.begin() + 1, 2, 10); + CB_CONTAINER<MyInteger> cb2(2, 3); + cb2.insert(cb2.begin(), 10, 5); + CB_CONTAINER<MyInteger> cb3(4); + cb3.insert(cb3.end(), 1, 6); + CB_CONTAINER<MyInteger> cb4(6); + cb4.push_back(1); + cb4.push_back(2); + cb4.push_back(3); + cb4.push_back(4); + cb4.insert(cb4.begin() + 2, 5, 6); + cb4.insert(cb4.begin() + 2, 0, 7); + CB_CONTAINER<MyInteger> cb5(3); + cb5.push_back(1); + cb5.push_back(2); + cb5.pop_front(); + cb5.insert(cb5.begin(), 2, 3); + + BOOST_TEST(cb1.full()); + BOOST_TEST(cb1[0] == 10); + BOOST_TEST(cb1[1] == 10); + BOOST_TEST(cb1[2] == 2); + BOOST_TEST(cb1[3] == 3); + BOOST_TEST(cb2[0] == 3); + BOOST_TEST(cb2[1] == 3); + BOOST_TEST(cb3[0] == 6); + BOOST_TEST(cb3.size() == 1); + BOOST_TEST(cb4.size() == 6); + BOOST_TEST(cb4[0] == 6); + BOOST_TEST(cb4[1] == 6); + BOOST_TEST(cb4[2] == 6); + BOOST_TEST(cb4[3] == 6); + BOOST_TEST(cb4[4] == 3); + BOOST_TEST(cb4[5] == 4); + BOOST_TEST(cb5.size() == 3); + BOOST_TEST(cb5[0] == 3); + BOOST_TEST(cb5[1] == 3); + BOOST_TEST(cb5[2] == 2); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); + generic_test(cb5); +} + +void insert_range_test() { + + vector<int> v; + v.push_back(11); + v.push_back(12); + v.push_back(13); + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.insert(cb1.begin() + 1, v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb2(2, 2); + cb2.insert(cb2.end(), v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb3(5); + cb3.insert(cb3.end(), v.end(), v.end()); + CB_CONTAINER<MyInteger> cb4(5); + cb4.insert(cb4.end(), v.begin(), v.begin() + 1); + MyInteger array[] = { 5, 6, 7, 8, 9 }; + CB_CONTAINER<MyInteger> cb5(6); + cb5.push_back(1); + cb5.push_back(2); + cb5.push_back(3); + cb5.push_back(4); + cb5.insert(cb5.begin() + 2, array, array + 5); + cb5.insert(cb5.begin(), array, array + 5); + + BOOST_TEST(cb1.full()); + BOOST_TEST(cb1[0] == 12); + BOOST_TEST(cb1[1] == 13); + BOOST_TEST(cb1[2] == 2); + BOOST_TEST(cb1[3] == 3); + BOOST_TEST(cb2[0] == 12); + BOOST_TEST(cb2[1] == 13); + BOOST_TEST(cb3.empty()); + BOOST_TEST(cb4[0] == 11); + BOOST_TEST(cb4.size() == 1); + BOOST_TEST(cb5.size() == 6); + BOOST_TEST(cb5[0] == 6); + BOOST_TEST(cb5[1] == 7); + BOOST_TEST(cb5[2] == 8); + BOOST_TEST(cb5[3] == 9); + BOOST_TEST(cb5[4] == 3); + BOOST_TEST(cb5[5] == 4); + +#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + + v.clear(); + v.push_back(1); + v.push_back(2); + v.push_back(3); + v.push_back(4); + v.push_back(5); + + CB_CONTAINER<int> cb6(4); + cb6.push_back(0); + cb6.push_back(-1); + cb6.push_back(-2); + cb6.insert(cb6.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end())); + v.clear(); + v.push_back(11); + v.push_back(12); + v.push_back(13); + CB_CONTAINER<int> cb7(4); + cb7.push_back(1); + cb7.push_back(2); + cb7.push_back(3); + cb7.insert(cb7.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end())); + CB_CONTAINER<int> cb8(2, 2); + cb8.insert(cb8.end(), MyInputIterator(v.begin()), MyInputIterator(v.end())); + CB_CONTAINER<int> cb9(5); + cb9.insert(cb9.end(), MyInputIterator(v.end()), MyInputIterator(v.end())); + CB_CONTAINER<int> cb10(5); + cb10.insert(cb10.end(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 1)); + v.clear(); + v.push_back(5); + v.push_back(6); + v.push_back(7); + v.push_back(8); + v.push_back(9); + CB_CONTAINER<int> cb11(6); + cb11.push_back(1); + cb11.push_back(2); + cb11.push_back(3); + cb11.push_back(4); + cb11.insert(cb11.begin() + 2, MyInputIterator(v.begin()), MyInputIterator(v.begin() + 5)); + cb11.insert(cb11.begin(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 5)); + + BOOST_TEST(cb6.capacity() == 4); + BOOST_TEST(cb6[0] == 4); + BOOST_TEST(cb6[3] == -2); + BOOST_TEST(cb7.full()); + BOOST_TEST(cb7[0] == 12); + BOOST_TEST(cb7[1] == 13); + BOOST_TEST(cb7[2] == 2); + BOOST_TEST(cb7[3] == 3); + BOOST_TEST(cb8[0] == 12); + BOOST_TEST(cb8[1] == 13); + BOOST_TEST(cb9.empty()); + BOOST_TEST(cb10[0] == 11); + BOOST_TEST(cb10.size() == 1); + BOOST_TEST(cb11.size() == 6); + BOOST_TEST(cb11[0] == 6); + BOOST_TEST(cb11[1] == 7); + BOOST_TEST(cb11[2] == 8); + BOOST_TEST(cb11[3] == 9); + BOOST_TEST(cb11[4] == 3); + BOOST_TEST(cb11[5] == 4); + +#endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); + generic_test(cb5); +} + +void push_front_test() { + + CB_CONTAINER<MyDefaultConstructible> cb1(5); + cb1.push_front(); + cb1.push_front(MyDefaultConstructible(2)); + BOOST_TEST(cb1[0].m_n == 2); + BOOST_TEST(cb1[1].m_n == 1); + + CB_CONTAINER<MyInteger> cb2(5); + cb2.push_front(); + BOOST_TEST(cb2.front() == CB_CONTAINER<MyInteger>::value_type()); + + cb2.push_front(1); + BOOST_TEST(cb2.front() == 1); + + CB_CONTAINER<MyInteger> cb3(0); + cb3.push_front(10); + BOOST_TEST(cb3.empty()); + + generic_test(cb2); + generic_test(cb3); +} + +void pop_front_test() { + + CB_CONTAINER<MyInteger> cb(4); + cb.push_front(1); + cb.push_front(2); + cb.push_front(3); + cb.push_front(4); + cb.push_front(5); + cb.pop_front(); + + BOOST_TEST(cb.size() == 3); + BOOST_TEST(!cb.full()); + BOOST_TEST(cb[0] == 4); + + generic_test(cb); +} + +void rinsert_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_front(1); + cb1.push_front(2); + cb1.push_front(3); + CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1; + it1 = cb1.rinsert(it1, 10); + CB_CONTAINER<MyInteger> cb2(4); + cb2.push_front(1); + cb2.rinsert(cb2.begin()); + cb2.rinsert(cb2.begin(), -1); + CB_CONTAINER<MyInteger>::iterator it2 = cb2.end() - 2; + it2 = cb2.rinsert(it2, 5); + CB_CONTAINER<MyInteger> cb3(2); + cb3.rinsert(cb3.begin(), 10); + cb3.rinsert(cb3.begin(), 20); + cb3.rinsert(cb3.end(), 30); + cb3.rinsert(cb3.begin(), 40); + CB_CONTAINER<MyInteger> cb4(4); + cb4.push_back(1); + cb4.push_back(2); + cb4.push_back(3); + CB_CONTAINER<MyInteger>::iterator it3 = cb4.begin() + 1; + it3 = cb4.rinsert(it3, 10); + CB_CONTAINER<MyInteger> cb5(4); + cb5.push_back(1); + cb5.rinsert(cb5.begin(), 0); + cb5.rinsert(cb5.begin(), -1); + CB_CONTAINER<MyInteger>::iterator it4 = cb5.begin() + 1; + it4 = cb5.rinsert(it4, 5); + CB_CONTAINER<MyInteger> cb6(2); + cb6.rinsert(cb6.end(), 10); + cb6.rinsert(cb6.end(), 20); + cb6.rinsert(cb6.begin(), 30); + cb6.rinsert(cb6.end(), 40); + CB_CONTAINER<MyInteger> cb7(6); + cb7.push_back(1); + cb7.push_back(2); + cb7.push_back(3); + cb7.push_back(4); + cb7.rinsert(cb7.begin() + 2, 5, 6); + + BOOST_TEST(cb1[1] == 10); + BOOST_TEST(*it1 == 10); + BOOST_TEST(cb1.full()); + BOOST_TEST(cb2[1] == 5); + BOOST_TEST(*it2 == 5); + BOOST_TEST(cb2.full()); + BOOST_TEST(cb2[3] == 1); + BOOST_TEST(cb3[0] == 40); + BOOST_TEST(cb3[1] == 20); + BOOST_TEST(cb4[1] == 10); + BOOST_TEST(*it3 == 10); + BOOST_TEST(cb4.full()); + BOOST_TEST(cb5[1] == 5); + BOOST_TEST(*it4 == 5); + BOOST_TEST(cb5.full()); + BOOST_TEST(cb6[0] == 30); + BOOST_TEST(cb6[1] == 10); + BOOST_TEST(cb7.size() == 6); + BOOST_TEST(cb7[0] == 1); + BOOST_TEST(cb7[1] == 2); + BOOST_TEST(cb7[2] == 6); + BOOST_TEST(cb7[3] == 6); + BOOST_TEST(cb7[4] == 6); + BOOST_TEST(cb7[5] == 6); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); + generic_test(cb5); + generic_test(cb6); + generic_test(cb7); +} + +void rinsert_n_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_front(1); + cb1.push_front(2); + cb1.push_front(3); + cb1.rinsert(cb1.begin() + 1, 2, 10); + CB_CONTAINER<MyInteger> cb2(2, 3); + cb2.rinsert(cb2.begin(), 10, 5); + CB_CONTAINER<MyInteger> cb3(4); + cb3.rinsert(cb3.end(), 1, 6); + CB_CONTAINER<MyInteger> cb4(4); + cb4.push_back(1); + cb4.push_back(2); + cb4.push_back(3); + cb4.rinsert(cb4.begin() + 1, 2, 10); + MyInteger array[] = { 5, 6, 7, 8, 9 }; + CB_CONTAINER<MyInteger> cb5(6); + cb5.push_back(1); + cb5.push_back(2); + cb5.push_back(3); + cb5.push_back(4); + cb5.rinsert(cb5.begin() + 2, array, array + 5); + cb5.rinsert(cb5.end(), array, array + 5); + + BOOST_TEST(cb1.full()); + BOOST_TEST(cb1[0] == 3); + BOOST_TEST(cb1[1] == 10); + BOOST_TEST(cb1[2] == 10); + BOOST_TEST(cb1[3] == 2); + BOOST_TEST(cb2[0] == 5); + BOOST_TEST(cb2[1] == 5); + BOOST_TEST(cb3[0] == 6); + BOOST_TEST(cb3.size() == 1); + BOOST_TEST(cb4.full()); + BOOST_TEST(cb4[0] == 1); + BOOST_TEST(cb4[1] == 10); + BOOST_TEST(cb4[2] == 10); + BOOST_TEST(cb4[3] == 2); + BOOST_TEST(cb5.size() == 6); + BOOST_TEST(cb5[0] == 1); + BOOST_TEST(cb5[1] == 2); + BOOST_TEST(cb5[2] == 5); + BOOST_TEST(cb5[3] == 6); + BOOST_TEST(cb5[4] == 7); + BOOST_TEST(cb5[5] == 8); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); + generic_test(cb5); +} + +void rinsert_range_test() { + + vector<int> v; + v.push_back(11); + v.push_back(12); + v.push_back(13); + v.push_back(14); + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.rinsert(cb1.begin() + 1, v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb2(2, 2); + cb2.rinsert(cb2.begin(), v.begin(), v.end()); + CB_CONTAINER<MyInteger> cb3(5); + cb3.rinsert(cb3.begin(), v.end(), v.end()); + CB_CONTAINER<MyInteger> cb4(5); + cb4.rinsert(cb4.begin(), v.begin(), v.begin() + 1); + + BOOST_TEST(cb1.full()); + BOOST_TEST(cb1[0] == 1); + BOOST_TEST(cb1[1] == 11); + BOOST_TEST(cb1[2] == 12); + BOOST_TEST(cb1[3] == 13); + BOOST_TEST(cb2[0] == 11); + BOOST_TEST(cb2[1] == 12); + BOOST_TEST(cb3.empty()); + BOOST_TEST(cb4[0] == 11); + BOOST_TEST(cb4.size() == 1); + +#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + + v.clear(); + v.push_back(1); + v.push_back(2); + v.push_back(3); + v.push_back(4); + v.push_back(5); + + CB_CONTAINER<int> cb10(4); + cb10.push_back(0); + cb10.push_back(-1); + cb10.push_back(-2); + cb10.rinsert(cb10.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end())); + v.clear(); + v.push_back(11); + v.push_back(12); + v.push_back(13); + v.push_back(14); + CB_CONTAINER<int> cb11(4); + cb11.push_back(1); + cb11.push_back(2); + cb11.push_back(3); + cb11.rinsert(cb11.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end())); + CB_CONTAINER<int> cb12(2, 2); + cb12.rinsert(cb12.begin(), MyInputIterator(v.begin()), MyInputIterator(v.end())); + CB_CONTAINER<int> cb13(5); + cb13.rinsert(cb13.begin(), MyInputIterator(v.end()), MyInputIterator(v.end())); + CB_CONTAINER<int> cb14(5); + cb14.rinsert(cb14.begin(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 1)); + + BOOST_TEST(cb10.capacity() == 4); + BOOST_TEST(cb10[0] == 0); + BOOST_TEST(cb10[3] == 3); + BOOST_TEST(cb11.full()); + BOOST_TEST(cb11[0] == 1); + BOOST_TEST(cb11[1] == 11); + BOOST_TEST(cb11[2] == 12); + BOOST_TEST(cb11[3] == 13); + BOOST_TEST(cb12[0] == 11); + BOOST_TEST(cb12[1] == 12); + BOOST_TEST(cb13.empty()); + BOOST_TEST(cb14[0] == 11); + BOOST_TEST(cb14.size() == 1); + +#endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); +} + +void erase_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + CB_CONTAINER<MyInteger>::iterator it1 = cb1.erase(cb1.begin() + 1); + + CB_CONTAINER<MyInteger> cb2(1, 1); + CB_CONTAINER<MyInteger>::iterator it2 = cb2.erase(cb2.begin()); + + CB_CONTAINER<MyInteger> cb3(4); + cb3.push_back(1); + cb3.push_back(2); + cb3.push_back(3); + CB_CONTAINER<MyInteger>::iterator it3 = cb3.erase(cb3.begin() + 2); + + BOOST_TEST(cb1.size() == 2); + BOOST_TEST(cb1.capacity() == 4); + BOOST_TEST(*it1 == 3); + BOOST_TEST(cb1[0] == 1); + BOOST_TEST(cb1[1] == 3); + BOOST_TEST(cb2.size() == 0); + BOOST_TEST(cb2.capacity() == 1); + BOOST_TEST(it2 == cb2.end()); + BOOST_TEST(cb3.size() == 2); + BOOST_TEST(cb3.capacity() == 4); + BOOST_TEST(it3 == cb3.end()); + BOOST_TEST(cb3[0] == 1); + BOOST_TEST(cb3[1] == 2); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); +} + +void erase_range_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + CB_CONTAINER<MyInteger>::iterator it1 = cb1.erase(cb1.begin() + 1, cb1.begin() + 3); + + CB_CONTAINER<MyInteger> cb2(4); + cb2.push_back(1); + cb2.push_back(2); + cb2.push_back(3); + cb2.push_back(4); + CB_CONTAINER<MyInteger>::iterator it2 = cb2.erase(cb2.begin(), cb2.begin()); + + CB_CONTAINER<MyInteger> cb3(4); + cb3.push_back(1); + cb3.push_back(2); + cb3.push_back(3); + cb3.push_back(4); + CB_CONTAINER<MyInteger>::iterator it3 = cb3.erase(cb3.begin() + 2, cb3.end()); + + CB_CONTAINER<MyInteger> cb4(10, 1); + CB_CONTAINER<MyInteger>::iterator it4 = cb4.erase(cb4.begin(), cb4.end()); + + BOOST_TEST(cb1.size() == 2); + BOOST_TEST(cb1.capacity() == 4); + BOOST_TEST(cb1[0] == 1); + BOOST_TEST(cb1[1] == 4); + BOOST_TEST(*it1 == 4); + BOOST_TEST(cb2.size() == 4); + BOOST_TEST(cb2[0] == 1); + BOOST_TEST(cb2[3] == 4); + BOOST_TEST(*it2 == 1); + BOOST_TEST(cb3.size() == 2); + BOOST_TEST(cb3.capacity() == 4); + BOOST_TEST(cb3[0] == 1); + BOOST_TEST(cb3[1] == 2); + BOOST_TEST(it3 == cb3.end()); + BOOST_TEST(cb4.size() == 0); + BOOST_TEST(cb4.capacity() == 10); + BOOST_TEST(it4 == cb4.end()); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); +} + +void rerase_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + CB_CONTAINER<MyInteger>::iterator it1 = cb1.rerase(cb1.begin() + 1); + + CB_CONTAINER<MyInteger> cb2(1, 1); + CB_CONTAINER<MyInteger>::iterator it2 = cb2.rerase(cb2.begin()); + + CB_CONTAINER<MyInteger> cb3(4); + cb3.push_back(1); + cb3.push_back(2); + cb3.push_back(3); + CB_CONTAINER<MyInteger>::iterator it3 = cb3.rerase(cb3.begin()); + + BOOST_TEST(cb1.size() == 2); + BOOST_TEST(cb1.capacity() == 4); + BOOST_TEST(*it1 == 1); + BOOST_TEST(cb1[0] == 1); + BOOST_TEST(cb1[1] == 3); + BOOST_TEST(cb2.size() == 0); + BOOST_TEST(cb2.capacity() == 1); + BOOST_TEST(it2 == cb2.begin()); + BOOST_TEST(cb3.size() == 2); + BOOST_TEST(cb3.capacity() == 4); + BOOST_TEST(it3 == cb3.begin()); + BOOST_TEST(*it3 == 2); + BOOST_TEST(cb3[0] == 2); + BOOST_TEST(cb3[1] == 3); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); +} + +void rerase_range_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + CB_CONTAINER<MyInteger>::iterator it1 = cb1.rerase(cb1.begin() + 1, cb1.begin() + 3); + + CB_CONTAINER<MyInteger> cb2(4); + cb2.push_back(1); + cb2.push_back(2); + cb2.push_back(3); + cb2.push_back(4); + CB_CONTAINER<MyInteger>::iterator it2 = cb2.rerase(cb2.begin(), cb2.begin()); + + CB_CONTAINER<MyInteger> cb3(4); + cb3.push_back(1); + cb3.push_back(2); + cb3.push_back(3); + cb3.push_back(4); + CB_CONTAINER<MyInteger>::iterator it3 = cb3.rerase(cb3.begin(), cb3.begin() + 2); + + CB_CONTAINER<MyInteger> cb4(10, 1); + CB_CONTAINER<MyInteger>::iterator it4 = cb4.rerase(cb4.begin(), cb4.end()); + + BOOST_TEST(cb1.size() == 2); + BOOST_TEST(cb1.capacity() == 4); + BOOST_TEST(cb1[0] == 1); + BOOST_TEST(cb1[1] == 4); + BOOST_TEST(*it1 == 1); + BOOST_TEST(cb2.size() == 4); + BOOST_TEST(cb2[0] == 1); + BOOST_TEST(cb2[3] == 4); + BOOST_TEST(*it2 == 1); + BOOST_TEST(cb3.size() == 2); + BOOST_TEST(cb3.capacity() == 4); + BOOST_TEST(cb3[0] == 3); + BOOST_TEST(cb3[1] == 4); + BOOST_TEST(it3 == cb3.begin()); + BOOST_TEST(cb4.size() == 0); + BOOST_TEST(cb4.capacity() == 10); + BOOST_TEST(it4 == cb4.begin()); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); +} + +void clear_test() { + + CB_CONTAINER<MyInteger> cb(4); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + cb.push_back(4); + cb.clear(); + + BOOST_TEST(cb.empty()); + + generic_test(cb); +} + +void equality_test() { + + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + CB_CONTAINER<MyInteger> cb2(10); + cb2.push_back(1); + cb2.push_back(2); + cb2.push_back(3); + cb2.push_back(4); + + BOOST_TEST(cb1 == cb2); + BOOST_TEST(!(cb2 != cb1)); + + generic_test(cb1); + generic_test(cb2); +} + +void lexicographical_comparison_test() { + + CB_CONTAINER<char> cb1(10); + cb1.push_back('a'); + cb1.push_back('d'); + cb1.push_back('a'); + cb1.push_back('m'); + CB_CONTAINER<char> cb2(5); + cb2.push_back('j'); + cb2.push_back('o'); + cb2.push_back('h'); + cb2.push_back('n'); + + BOOST_TEST(cb2 > cb1); + BOOST_TEST(cb1 < cb2); +} + +void assign_range_test() { + + vector<int> v; + v.push_back(11); + v.push_back(12); + v.push_back(13); + CB_CONTAINER<MyInteger> cb1(4); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.assign(v.begin() + 1, v.end()); + CB_CONTAINER<MyInteger> cb2(2); + cb2.push_back(1); + cb2.push_back(2); + cb2.assign(v.begin(), v.end()); + + BOOST_TEST(cb1.capacity() == 2); + BOOST_TEST(cb1[0] == 12); + BOOST_TEST(cb1[1] == 13); + BOOST_TEST(cb2.full()); + BOOST_TEST(cb2.capacity() == 3); + BOOST_TEST(cb2[0] == 11); + BOOST_TEST(cb2[1] == 12); + BOOST_TEST(cb2[2] == 13); + BOOST_TEST(cb2.size() == (size_t)distance(v.begin(), v.end())); + + generic_test(cb1); + generic_test(cb2); +} + +// test of the example (introduced in the documentation) +void example_test() { + + CB_CONTAINER<int> cb1(3); + cb1.push_back(1); + cb1.push_back(2); + + BOOST_TEST(cb1[0] == 1); + BOOST_TEST(cb1[1] == 2); + BOOST_TEST(!cb1.full()); + BOOST_TEST(cb1.size() == 2); + BOOST_TEST(cb1.capacity() == 3); + + cb1.push_back(3); + cb1.push_back(4); + int sum = accumulate(cb1.begin(), cb1.end(), 0); + + BOOST_TEST(cb1[0] == 2); + BOOST_TEST(cb1[1] == 3); + BOOST_TEST(cb1[2] == 4); + BOOST_TEST(*cb1.begin() == 2); + BOOST_TEST(cb1.front() == 2); + BOOST_TEST(cb1.back() == 4); + BOOST_TEST(sum == 9); + BOOST_TEST(cb1.full()); + BOOST_TEST(cb1.size() == 3); + BOOST_TEST(cb1.capacity() == 3); + + CB_CONTAINER<int> cb2(5, 1); + cb2.insert(cb2.begin(), 2); + + BOOST_TEST(cb2[0] == 1); + BOOST_TEST(cb2[1] == 1); + BOOST_TEST(cb2[2] == 1); + BOOST_TEST(cb2[3] == 1); + BOOST_TEST(cb2[4] == 1); + + vector<int> v; + v.push_back(100); + v.push_back(200); + v.push_back(300); + cb2.insert(cb2.begin() + 1, v.begin(), v.end()); + + BOOST_TEST(cb2[0] == 300); + BOOST_TEST(cb2[1] == 1); + BOOST_TEST(cb2[2] == 1); + BOOST_TEST(cb2[3] == 1); + BOOST_TEST(cb2[4] == 1); + + CB_CONTAINER<int> cb3(3); + cb3.push_back(1); + cb3.push_back(2); + cb3.push_back(3); + + BOOST_TEST(cb3[0] == 1); + BOOST_TEST(cb3[1] == 2); + BOOST_TEST(cb3[2] == 3); + + cb3.push_back(4); + cb3.push_back(5); + + BOOST_TEST(cb3[0] == 3); + BOOST_TEST(cb3[1] == 4); + BOOST_TEST(cb3[2] == 5); + + cb3.pop_back(); + cb3.pop_front(); + + BOOST_TEST(cb3[0] == 4); +} + +void element_destruction_test() { + + CB_CONTAINER<InstanceCounter> cb(5); + cb.push_back(InstanceCounter()); + cb.push_back(InstanceCounter()); + cb.push_back(InstanceCounter()); + int prevCount = InstanceCounter::count(); + cb.clear(); + + BOOST_TEST(cb.empty()); + BOOST_TEST(prevCount == 3); + BOOST_TEST(InstanceCounter::count() == 0); +} + +void const_methods_test() { + + vector<int> v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + v.push_back(4); + v.push_back(5); + const CB_CONTAINER<MyInteger> cb(5, v.begin(), v.end()); + + BOOST_TEST(*cb.begin() == 1); + BOOST_TEST(*(cb.end() - 1) == 5); + BOOST_TEST(*cb.rbegin() == 5); + BOOST_TEST(*(cb.rend() - 1) == 1); + BOOST_TEST(cb[0] == 1); + BOOST_TEST(cb.at(1) == 2); + BOOST_TEST(cb.front() == 1); + BOOST_TEST(cb.back() == 5); +} + +void rotate_test() { + + CB_CONTAINER<MyInteger> cb1(10); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.push_back(5); + cb1.push_back(6); + cb1.push_back(7); + CB_CONTAINER<MyInteger> cb2 = cb1; + CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 2; + int v1_0 = *it1; + int v1_1 = *(it1 + 1); + int v1_2 = *(it1 + 2); + int v1_3 = *(it1 + 3); + int v1_4 = *(it1 + 4); + int v1_r1 = *(it1 - 1); + int v1_r2 = *(it1 - 2); + cb1.rotate(it1); + rotate(cb2.begin(), cb2.begin() + 2, cb2.end()); + + CB_CONTAINER<MyInteger> cb3(7); + cb3.push_back(1); + cb3.push_back(2); + cb3.push_back(3); + cb3.push_back(4); + cb3.push_back(5); + cb3.push_back(6); + cb3.push_back(7); + cb3.push_back(8); + cb3.push_back(9); + CB_CONTAINER<MyInteger> cb4 = cb3; + CB_CONTAINER<MyInteger>::iterator it2 = cb3.begin() + 1; + int v2_0 = *it2; + int v2_1 = *(it2 + 1); + int v2_2 = *(it2 + 2); + int v2_3 = *(it2 + 3); + int v2_4 = *(it2 + 4); + int v2_5 = *(it2 + 5); + int v2_r1 = *(it2 - 1); + cb3.rotate(it2); + rotate(cb4.begin(), cb4.begin() + 1, cb4.end()); + + CB_CONTAINER<MyInteger> cb5(10); + cb5.push_back(1); + cb5.push_back(2); + cb5.push_back(3); + cb5.push_back(4); + cb5.push_back(5); + cb5.push_back(6); + cb5.push_back(7); + CB_CONTAINER<MyInteger> cb6 = cb5; + CB_CONTAINER<MyInteger>::iterator it3 = cb5.begin() + 5; + int v3_0 = *it3; + int v3_1 = *(it3 + 1); + int v3_r1 = *(it3 - 1); + int v3_r2 = *(it3 - 2); + int v3_r3 = *(it3 - 3); + int v3_r4 = *(it3 - 4); + int v3_r5 = *(it3 - 5); + cb5.rotate(it3); + rotate(cb6.begin(), cb6.begin() + 5, cb6.end()); + + BOOST_TEST(!cb1.full()); + BOOST_TEST(cb1 == cb2); + BOOST_TEST(v1_0 == *it1); + BOOST_TEST(v1_1 == *(it1 + 1)); + BOOST_TEST(v1_2 == *(it1 + 2)); + BOOST_TEST(v1_3 == *(it1 + 3)); + BOOST_TEST(v1_4 == *(it1 + 4)); + BOOST_TEST(v1_r1 == *(it1 + 6)); + BOOST_TEST(v1_r2 == *(it1 + 5)); + BOOST_TEST(cb1.begin() == it1); + BOOST_TEST(v1_0 == cb1[0]); + BOOST_TEST(v1_1 == cb1[1]); + BOOST_TEST(v1_2 == cb1[2]); + BOOST_TEST(v1_3 == cb1[3]); + BOOST_TEST(v1_4 == cb1[4]); + BOOST_TEST(v1_r1 == cb1[6]); + BOOST_TEST(v1_r2 == cb1[5]); + BOOST_TEST(cb3.full()); + BOOST_TEST(cb3 == cb4); + BOOST_TEST(v2_0 == *it2); + BOOST_TEST(v2_1 == *(it2 + 1)); + BOOST_TEST(v2_2 == *(it2 + 2)); + BOOST_TEST(v2_3 == *(it2 + 3)); + BOOST_TEST(v2_4 == *(it2 + 4)); + BOOST_TEST(v2_5 == *(it2 + 5)); + BOOST_TEST(v2_r1 == *(it2 + 6)); + BOOST_TEST(cb3.begin() == it2); + BOOST_TEST(v2_0 == cb3[0]); + BOOST_TEST(v2_1 == cb3[1]); + BOOST_TEST(v2_2 == cb3[2]); + BOOST_TEST(v2_3 == cb3[3]); + BOOST_TEST(v2_4 == cb3[4]); + BOOST_TEST(v2_5 == cb3[5]); + BOOST_TEST(v2_r1 == cb3[6]); + BOOST_TEST(!cb5.full()); + BOOST_TEST(cb5 == cb6); + BOOST_TEST(v3_0 == cb5[0]); + BOOST_TEST(v3_1 == cb5[1]); + BOOST_TEST(v3_r1 == cb5[6]); + BOOST_TEST(v3_r2 == cb5[5]); + BOOST_TEST(v3_r3 == cb5[4]); + BOOST_TEST(v3_r4 == cb5[3]); + BOOST_TEST(v3_r5 == cb5[2]); + + generic_test(cb1); + generic_test(cb2); + generic_test(cb3); + generic_test(cb4); + generic_test(cb5); + generic_test(cb6); +} + +int MyInteger::ms_exception_trigger = 0; +int InstanceCounter::ms_count = 0; + +void move_container_on_cpp11() { +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + CB_CONTAINER<MyInteger> cb1(10); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.push_back(5); + cb1.push_back(6); + + // Checking move constructor + CB_CONTAINER<MyInteger> cb2(static_cast<CB_CONTAINER<MyInteger>&& >(cb1)); + CB_CONTAINER<MyInteger>::iterator it2 = cb2.begin() + 1; + + BOOST_TEST(cb1.empty()); + BOOST_TEST(!cb2.empty()); + BOOST_TEST(it2[0] == 2); + BOOST_TEST(it2[-1] == 1); + BOOST_TEST(it2[2] == 4); + + // Checking move assignment + cb1 = static_cast<CB_CONTAINER<MyInteger>&& >(cb2); + CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1; + + BOOST_TEST(!cb1.empty()); + BOOST_TEST(cb2.empty()); + BOOST_TEST(it1[0] == 2); + BOOST_TEST(it1[-1] == 1); + BOOST_TEST(it1[2] == 4); +#endif +} + + +struct noncopyable_movable_except_t +{ +private: + BOOST_MOVABLE_BUT_NOT_COPYABLE(noncopyable_movable_except_t) + bool is_moved_; + int value_; +public: + static int next_value; + + explicit noncopyable_movable_except_t() + : is_moved_(false) + , value_(next_value ++) + {} + + noncopyable_movable_except_t(BOOST_RV_REF(noncopyable_movable_except_t) x) { + is_moved_ = x.is_moved_; + value_ = x.value_; + x.is_moved_ = true; + } + + noncopyable_movable_except_t& operator=(BOOST_RV_REF(noncopyable_movable_except_t) x) { + is_moved_ = x.is_moved_; + value_ = x.value_; + x.is_moved_ = true; + return *this; + } + + bool is_moved() const { + return is_moved_; + } + + int value() const { + return value_; + } + + void reinit() { is_moved_ = false; value_ = next_value ++; } +}; + +struct noncopyable_movable_noexcept_t +{ +private: + BOOST_MOVABLE_BUT_NOT_COPYABLE(noncopyable_movable_noexcept_t) + bool is_moved_; + int value_; +public: + static int next_value; + + explicit noncopyable_movable_noexcept_t() + : is_moved_(false) + , value_(next_value ++) + {} + + noncopyable_movable_noexcept_t(BOOST_RV_REF(noncopyable_movable_noexcept_t) x) BOOST_NOEXCEPT { + is_moved_ = x.is_moved_; + value_ = x.value_; + x.is_moved_ = true; + } + + noncopyable_movable_noexcept_t& operator=(BOOST_RV_REF(noncopyable_movable_noexcept_t) x) BOOST_NOEXCEPT { + is_moved_ = x.is_moved_; + value_ = x.value_; + x.is_moved_ = true; + return *this; + } + + bool is_moved() const { + return is_moved_; + } + + int value() const { + return value_; + } + + void reinit() { is_moved_ = false; value_ = next_value ++; } +}; + +#if defined(BOOST_NO_CXX11_NOEXCEPT) || !defined(BOOST_IS_NOTHROW_MOVE_CONSTRUCT) +namespace boost { + template <> + struct is_nothrow_move_constructible<noncopyable_movable_noexcept_t> + : boost::true_type + {}; +} +#endif + +int noncopyable_movable_noexcept_t::next_value = 1; +int noncopyable_movable_except_t::next_value = 1; + +template <class T> +void move_container_values_impl() { + typedef T noncopyable_movable_test_t; + noncopyable_movable_test_t::next_value = 1; + + CB_CONTAINER<noncopyable_movable_test_t> cb1(40); + noncopyable_movable_test_t var; + cb1.push_back(boost::move(var)); + BOOST_TEST(!cb1.back().is_moved()); + BOOST_TEST(cb1.back().value() == 1); + BOOST_TEST(var.is_moved()); + BOOST_TEST(cb1.size() == 1); + + var.reinit(); + cb1.push_front(boost::move(var)); + BOOST_TEST(!cb1.front().is_moved()); + BOOST_TEST(cb1.front().value() == 2); + BOOST_TEST(var.is_moved()); + BOOST_TEST(cb1.size() == 2); + + cb1.push_back(); + BOOST_TEST(!cb1.back().is_moved()); + BOOST_TEST(cb1.back().value() == 3); + BOOST_TEST(cb1.size() == 3); + + cb1.push_front(); + BOOST_TEST(!cb1.front().is_moved()); + BOOST_TEST(cb1.front().value() == 4); + BOOST_TEST(cb1.size() == 4); + + cb1.insert(cb1.begin()); + BOOST_TEST(!cb1.front().is_moved()); + BOOST_TEST(cb1.front().value() == 5); + BOOST_TEST(cb1.size() == 5); + + var.reinit(); + cb1.insert(cb1.begin(), boost::move(var)); + BOOST_TEST(!cb1.front().is_moved()); + BOOST_TEST(cb1.front().value() == 6); + BOOST_TEST(cb1.size() == 6); + + cb1.rinsert(cb1.begin()); + BOOST_TEST(!cb1.front().is_moved()); + BOOST_TEST(cb1.front().value() == 7); + BOOST_TEST(cb1.size() == 7); + + var.reinit(); + cb1.rinsert(cb1.begin(), boost::move(var)); + BOOST_TEST(!cb1.front().is_moved()); + BOOST_TEST(cb1.front().value() == 8); + BOOST_TEST(cb1.size() == 8); + + + BOOST_TEST(cb1[0].value() == 8); + BOOST_TEST(cb1[1].value() == 7); + BOOST_TEST(cb1[2].value() == 6); + BOOST_TEST(cb1[3].value() == 5); + BOOST_TEST(cb1[4].value() == 4); + BOOST_TEST(cb1[5].value() == 2); + BOOST_TEST(cb1[6].value() == 1); + BOOST_TEST(cb1[7].value() == 3); + cb1.rotate(cb1.begin() + 2); + BOOST_TEST(cb1[0].value() == 6); + BOOST_TEST(cb1[1].value() == 5); + BOOST_TEST(cb1[2].value() == 4); + BOOST_TEST(cb1[3].value() == 2); + BOOST_TEST(cb1[4].value() == 1); + BOOST_TEST(cb1[5].value() == 3); + BOOST_TEST(cb1[6].value() == 8); + BOOST_TEST(cb1[7].value() == 7); + + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(!cb1[2].is_moved()); + BOOST_TEST(!cb1[3].is_moved()); + BOOST_TEST(!cb1[4].is_moved()); + BOOST_TEST(!cb1[5].is_moved()); + BOOST_TEST(!cb1[6].is_moved()); + BOOST_TEST(!cb1[7].is_moved()); + + cb1.linearize(); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(!cb1[2].is_moved()); + BOOST_TEST(!cb1[3].is_moved()); + BOOST_TEST(!cb1[4].is_moved()); + BOOST_TEST(!cb1[5].is_moved()); + BOOST_TEST(!cb1[6].is_moved()); + BOOST_TEST(!cb1[7].is_moved()); + BOOST_TEST(cb1[0].value() == 6); + BOOST_TEST(cb1[1].value() == 5); + BOOST_TEST(cb1[2].value() == 4); + BOOST_TEST(cb1[3].value() == 2); + BOOST_TEST(cb1[4].value() == 1); + BOOST_TEST(cb1[5].value() == 3); + BOOST_TEST(cb1[6].value() == 8); + BOOST_TEST(cb1[7].value() == 7); + + cb1.erase(cb1.begin()); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(!cb1[2].is_moved()); + BOOST_TEST(!cb1[3].is_moved()); + BOOST_TEST(!cb1[4].is_moved()); + BOOST_TEST(!cb1[5].is_moved()); + BOOST_TEST(!cb1[6].is_moved()); + BOOST_TEST(cb1[0].value() == 5); + BOOST_TEST(cb1[1].value() == 4); + BOOST_TEST(cb1[2].value() == 2); + BOOST_TEST(cb1[3].value() == 1); + BOOST_TEST(cb1[4].value() == 3); + BOOST_TEST(cb1[5].value() == 8); + BOOST_TEST(cb1[6].value() == 7); + + cb1.rerase(cb1.begin()); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(!cb1[2].is_moved()); + BOOST_TEST(!cb1[3].is_moved()); + BOOST_TEST(!cb1[4].is_moved()); + BOOST_TEST(!cb1[5].is_moved()); + BOOST_TEST(cb1[0].value() == 4); + BOOST_TEST(cb1[1].value() == 2); + BOOST_TEST(cb1[2].value() == 1); + BOOST_TEST(cb1[3].value() == 3); + BOOST_TEST(cb1[4].value() == 8); + BOOST_TEST(cb1[5].value() == 7); + + cb1.erase(cb1.begin(), cb1.begin() + 1); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(!cb1[2].is_moved()); + BOOST_TEST(!cb1[3].is_moved()); + BOOST_TEST(!cb1[4].is_moved()); + BOOST_TEST(cb1[0].value() == 2); + BOOST_TEST(cb1[1].value() == 1); + BOOST_TEST(cb1[2].value() == 3); + BOOST_TEST(cb1[3].value() == 8); + BOOST_TEST(cb1[4].value() == 7); + + cb1.rerase(cb1.begin(), cb1.begin() + 1); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(!cb1[2].is_moved()); + BOOST_TEST(!cb1[3].is_moved()); + BOOST_TEST(cb1[0].value() == 1); + BOOST_TEST(cb1[1].value() == 3); + BOOST_TEST(cb1[2].value() == 8); + BOOST_TEST(cb1[3].value() == 7); +} + +void move_container_values_noexcept() { + move_container_values_impl<noncopyable_movable_noexcept_t>(); + + typedef noncopyable_movable_noexcept_t noncopyable_movable_test_t; + noncopyable_movable_test_t::next_value = 1; + CB_CONTAINER<noncopyable_movable_test_t> cb1(40); + cb1.push_back(); + cb1.push_back(); + cb1.push_back(); + cb1.push_back(); + cb1.push_back(); + cb1.push_back(); + cb1.push_back(); + cb1.push_back(); + + cb1.set_capacity(100); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(!cb1[2].is_moved()); + BOOST_TEST(!cb1[3].is_moved()); + BOOST_TEST(!cb1[4].is_moved()); + BOOST_TEST(!cb1[5].is_moved()); + BOOST_TEST(!cb1[6].is_moved()); + BOOST_TEST(!cb1[7].is_moved()); + BOOST_TEST(cb1[0].value() == 1); + BOOST_TEST(cb1[1].value() == 2); + BOOST_TEST(cb1[2].value() == 3); + BOOST_TEST(cb1[3].value() == 4); + BOOST_TEST(cb1[4].value() == 5); + BOOST_TEST(cb1[5].value() == 6); + BOOST_TEST(cb1[6].value() == 7); + BOOST_TEST(cb1[7].value() == 8); + + cb1.rset_capacity(101); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(!cb1[2].is_moved()); + BOOST_TEST(!cb1[3].is_moved()); + BOOST_TEST(!cb1[4].is_moved()); + BOOST_TEST(!cb1[5].is_moved()); + BOOST_TEST(!cb1[6].is_moved()); + BOOST_TEST(!cb1[7].is_moved()); + BOOST_TEST(cb1[0].value() == 1); + BOOST_TEST(cb1[1].value() == 2); + BOOST_TEST(cb1[2].value() == 3); + BOOST_TEST(cb1[3].value() == 4); + BOOST_TEST(cb1[4].value() == 5); + BOOST_TEST(cb1[5].value() == 6); + BOOST_TEST(cb1[6].value() == 7); + BOOST_TEST(cb1[7].value() == 8); + + cb1.set_capacity(2); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(!cb1[1].is_moved()); + BOOST_TEST(cb1[0].value() == 1); + BOOST_TEST(cb1[1].value() == 2); + + cb1.rset_capacity(1); + BOOST_TEST(!cb1[0].is_moved()); + BOOST_TEST(cb1[0].value() == 2); +} + +void check_containers_exception_specifications() { +#ifndef BOOST_NO_CXX11_NOEXCEPT +#ifndef BOOST_CLANG + // Clang has an error in __has_nothrow_constructor implementation: + // http://llvm.org/bugs/show_bug.cgi?id=16627 + BOOST_TEST(boost::has_nothrow_constructor<CB_CONTAINER<int> >::value); +#endif + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +#ifdef BOOST_IS_NOTHROW_MOVE_ASSIGN + BOOST_TEST(boost::is_nothrow_move_assignable<CB_CONTAINER<int> >::value); +#endif +#ifdef BOOST_IS_NOTHROW_MOVE_CONSTRUCT + BOOST_TEST(boost::is_nothrow_move_constructible<CB_CONTAINER<int> >::value); +#endif +#endif +#endif // BOOST_NO_CXX11_NOEXCEPT +} + +// add common tests into a test suite +void run_common_tests() +{ + basic_test(); + constructor_and_element_access_test(); + size_test(); + allocator_test(); + begin_and_end_test(); + rbegin_and_rend_test(); + element_access_and_insert_test(); + at_test(); + front_and_back_test(); + linearize_test(); + array_range_test(); + capacity_and_reserve_test(); + full_and_empty_test(); + set_capacity_test(); + rset_capacity_test(); + resize_test(); + rresize_test(); + constructor_test(); + assign_test(); + copy_constructor_and_assign_test(); + swap_test(); + push_back_test(); + pop_back_test(); + insert_test(); + insert_n_test(); + insert_range_test(); + push_front_test(); + pop_front_test(); + rinsert_test(); + rinsert_n_test(); + rinsert_range_test(); + erase_test(); + erase_range_test(); + rerase_test(); + rerase_range_test(); + clear_test(); + equality_test(); + lexicographical_comparison_test(); + assign_range_test(); + example_test(); + element_destruction_test(); + const_methods_test(); + rotate_test(); + move_container_on_cpp11(); + move_container_values_noexcept(); + check_containers_exception_specifications(); +#if !defined(BOOST_CB_NO_CXX11_ALLOCATOR) + cxx11_allocator_test(); +#endif +} + diff --git a/src/boost/libs/circular_buffer/test/constant_erase_test.cpp b/src/boost/libs/circular_buffer/test/constant_erase_test.cpp new file mode 100644 index 000000000..e2431be2a --- /dev/null +++ b/src/boost/libs/circular_buffer/test/constant_erase_test.cpp @@ -0,0 +1,182 @@ +// Special tests for erase_begin, erase_end and clear methods. + +// Copyright (c) 2009 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" + +int MyInteger::ms_exception_trigger = 0; +int InstanceCounter::ms_count = 0; + +void erase_begin_test() { + + circular_buffer<int> cb1(5); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.push_back(5); + cb1.push_back(6); + + circular_buffer<int>::pointer p = &cb1[0]; + + cb1.erase_begin(2); + + 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_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_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_TEST(cb2.size() == 5); + BOOST_TEST(InstanceCounter::count() == 5); + + cb2.erase_begin(2); + + BOOST_TEST(cb2.size() == 3); + BOOST_TEST(InstanceCounter::count() == 3); + + 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); + cb3.push_back(6); + cb3.erase_begin(2); + + BOOST_TEST(cb3.size() == 3); + BOOST_TEST(cb3[0] == 4); + BOOST_TEST(cb3[1] == 5); + BOOST_TEST(cb3[2] == 6); +} + +void erase_end_test() { + + circular_buffer<int> cb1(5); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.push_back(5); + cb1.push_back(6); + + circular_buffer<int>::pointer p = &cb1[3]; + + cb1.erase_end(2); + + 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_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_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_TEST(cb2.size() == 5); + BOOST_TEST(InstanceCounter::count() == 5); + + cb2.erase_end(2); + + BOOST_TEST(cb2.size() == 3); + BOOST_TEST(InstanceCounter::count() == 3); + + 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); + cb3.push_back(6); + cb3.erase_end(2); + + BOOST_TEST(cb3.size() == 3); + BOOST_TEST(cb3[0] == 2); + BOOST_TEST(cb3[1] == 3); + BOOST_TEST(cb3[2] == 4); +} + +void clear_test() { + + circular_buffer<int> cb1(5); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb1.push_back(5); + cb1.push_back(6); + + circular_buffer<int>::pointer p = &cb1[0]; + + cb1.clear(); + + 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_TEST(cb2.size() == 5); + BOOST_TEST(InstanceCounter::count() == 5); + + cb2.clear(); + + BOOST_TEST(cb2.empty()); + BOOST_TEST(InstanceCounter::count() == 0); + + 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); + cb3.push_back(6); + cb3.clear(); + + BOOST_TEST(cb3.empty()); +} + +// test main +int main() +{ + erase_begin_test(); + erase_end_test(); + clear_test(); + return boost::report_errors(); +} diff --git a/src/boost/libs/circular_buffer/test/soft_iterator_invalidation.cpp b/src/boost/libs/circular_buffer/test/soft_iterator_invalidation.cpp new file mode 100644 index 000000000..c266c9c93 --- /dev/null +++ b/src/boost/libs/circular_buffer/test/soft_iterator_invalidation.cpp @@ -0,0 +1,742 @@ +// Demonstration of rules when an iterator is considered to be valid if the soft +// iterator invalidation definition is applied. +// Note: The soft iterator invalidation definition CAN NOT be applied +// to the space optimized circular buffer. + +// 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" + +// test of the example (introduced in the documentation) +void validity_example_test() { + + circular_buffer<int> cb(3); + + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + circular_buffer<int>::iterator it = cb.begin(); + + BOOST_TEST(*it == 1); + + cb.push_back(4); + + BOOST_TEST(*it == 4); +} + +void validity_insert_test() { + + int array[] = { 1, 2, 3 }; + + // memory placement: { 1, 2, 3 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(4, array, array + 3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + + cb.insert(cb.begin() + 1, 4); + + // memory placement: { 1, 4, 2, 3 } + // circular buffer: { 1, 4, 2, 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; + + cb.insert(cb.begin() + 1, 5); + + // memory placement: { 3, 5, 4, 2 } + // circular buffer: { 5, 4, 2, 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() { + + // memory placement: { 1, 2, 3 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(5); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + + cb.insert(cb.begin() + 1, 2, 4); + + // memory placement: { 1, 4, 4, 2, 3 } + // circular buffer: { 1, 4, 4, 2, 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; + circular_buffer<int>::iterator it5 = it1 + 4; + + cb.insert(cb.begin() + 1, 2, 5); + + // memory placement: { 3, 5, 4, 4, 2 } - 5 inserted only once + // circular buffer: { 5, 4, 4, 2, 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() { + + vector<int> v1; + v1.push_back(4); + v1.push_back(5); + + vector<int> v2; + v2.push_back(6); + v2.push_back(7); + + + // memory placement: { 1, 2, 3 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb1(5); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + + // it11 -> 1, it12 -> 2, it13 -> 3 + circular_buffer<int>::iterator it11 = cb1.begin(); + circular_buffer<int>::iterator it12 = cb1.begin() + 1; + circular_buffer<int>::iterator it13 = cb1.begin() + 2; + + cb1.insert(cb1.begin() + 1, v1.begin(), v1.end()); + + // memory placement: { 1, 4, 5, 2, 3 } + // circular buffer: { 1, 4, 5, 2, 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; + circular_buffer<int>::iterator it15 = it11 + 4; + + cb1.insert(cb1.begin() + 1, v2.begin(), v2.end()); + + // memory placement: { 3, 7, 4, 5, 2 } - 7 inserted only + // circular buffer: { 7, 4, 5, 2, 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 } + circular_buffer<int> cb2(5); + cb2.push_back(1); + cb2.push_back(2); + cb2.push_back(3); + + // it21 -> 1, it22 -> 2, it23 -> 3 + circular_buffer<int>::iterator it21 = cb2.begin(); + circular_buffer<int>::iterator it22 = cb2.begin() + 1; + circular_buffer<int>::iterator it23 = cb2.begin() + 2; + + cb2.insert(cb2.begin() + 1, MyInputIterator(v1.begin()), MyInputIterator(v1.end())); + + // memory placement: { 1, 4, 5, 2, 3 } + // circular buffer: { 1, 4, 5, 2, 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; + circular_buffer<int>::iterator it25 = it21 + 4; + + cb2.insert(cb2.begin() + 1, MyInputIterator(v2.begin()), MyInputIterator(v2.end())); + + // 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_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() { + + int array[] = { 1, 2, 3 }; + + // memory placement: { 1, 2, 3 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(4, array, array + 3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + + cb.rinsert(cb.begin() + 2, 4); + + // memory placement: { 2, 4, 3, 1 } + // circular buffer: { 1, 2, 4, 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; + + cb.rinsert(cb.begin() + 2, 5); + + // memory placement: { 5, 4, 1, 2 } + // circular buffer: { 1, 2, 5, 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() { + + // memory placement: { 1, 2, 3 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(5); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + + cb.rinsert(cb.begin() + 2, 2, 4); + + // memory placement: { 4, 4, 3, 1, 2 } + // circular buffer: { 1, 2, 4, 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; + circular_buffer<int>::iterator it5 = it1 - 1; + + cb.rinsert(cb.begin() + 4, 2, 5); + + // memory placement: { 4, 5, 1, 2, 4 } - 5 inserted only once + // circular buffer: { 1, 2, 4, 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() { + + vector<int> v1; + v1.push_back(4); + v1.push_back(5); + + vector<int> v2; + v2.push_back(6); + v2.push_back(7); + + + // memory placement: { 1, 2, 3 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb1(5); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it11 = cb1.begin(); + circular_buffer<int>::iterator it12 = cb1.begin() + 1; + circular_buffer<int>::iterator it13 = cb1.begin() + 2; + + cb1.rinsert(cb1.begin() + 2, v1.begin(), v1.end()); + + // memory placement: { 4, 5, 3, 1, 2 } + // circular buffer: { 1, 2, 4, 5, 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; + circular_buffer<int>::iterator it15 = it11 - 1; + + cb1.rinsert(cb1.begin() + 4, v2.begin(), v2.end()); + + // memory placement: { 5, 6, 1, 2, 4 } - 6 inserted only + // circular buffer: { 1, 2, 4, 5, 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 } + circular_buffer<int> cb2(5); + cb2.push_back(1); + cb2.push_back(2); + cb2.push_back(3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it21 = cb2.begin(); + circular_buffer<int>::iterator it22 = cb2.begin() + 1; + circular_buffer<int>::iterator it23 = cb2.begin() + 2; + + cb2.rinsert(cb2.begin() + 2, MyInputIterator(v1.begin()), MyInputIterator(v1.end())); + + // memory placement: { 4, 5, 3, 1, 2 } + // circular buffer: { 1, 2, 4, 5, 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; + circular_buffer<int>::iterator it25 = it21 - 1; + + cb2.rinsert(cb2.begin() + 4, MyInputIterator(v2.begin()), MyInputIterator(v2.end())); + + // memory placement: { 5, 6, 1, 2, 4 } + // circular buffer: { 1, 2, 4, 5, 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() { + + // memory placement: { 4, 5, 1, 2, 3 } + // circular buffer: { 1, 2, 3, 4, 5 } + circular_buffer<int> cb(5); + cb.push_back(-1); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + cb.push_back(4); + cb.push_back(5); + + // it1 -> 1, it2 -> 2, it3 -> 3, it4 -> 4 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + circular_buffer<int>::iterator it4 = cb.begin() + 3; + + cb.erase(cb.begin() + 1); + + // memory placement: { 5, X, 1, 3, 4 } + // circular buffer: { 1, 3, 4, 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() { + + // memory placement: { 4, 5, 6, 1, 2, 3 } + // circular buffer: { 1, 2, 3, 4, 5, 6 } + circular_buffer<int> cb(6); + cb.push_back(-2); + cb.push_back(-1); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + cb.push_back(4); + cb.push_back(5); + cb.push_back(6); + + // it1 -> 1, it2 -> 2, it3 -> 3, it4 -> 4 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + circular_buffer<int>::iterator it4 = cb.begin() + 3; + + cb.erase(cb.begin() + 2, cb.begin() + 4); + + // memory placement: { 6, X, X, 1, 2, 5 } + // circular buffer: { 1, 2, 5, 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() { + + // memory placement: { 4, 5, 1, 2, 3 } + // circular buffer: { 1, 2, 3, 4, 5 } + circular_buffer<int> cb(5); + cb.push_back(-1); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + cb.push_back(4); + cb.push_back(5); + + // it1 -> 2, it2 -> 3, it3 -> 4, it4 -> 5 + circular_buffer<int>::iterator it1 = cb.begin() + 1; + circular_buffer<int>::iterator it2 = cb.begin() + 2; + circular_buffer<int>::iterator it3 = cb.begin() + 3; + circular_buffer<int>::iterator it4 = cb.begin() + 4; + + cb.rerase(cb.begin() + 1); + + // memory placement: { 4, 5, X, 1, 3 } + // circular buffer: { 1, 3, 4, 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() { + + // memory placement: { 4, 5, 6, 1, 2, 3 } + // circular buffer: { 1, 2, 3, 4, 5, 6 } + circular_buffer<int> cb(6); + cb.push_back(-2); + cb.push_back(-1); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + cb.push_back(4); + cb.push_back(5); + cb.push_back(6); + + // it1 -> 3, it2 -> 4, it3 -> 5, it4 -> 6 + circular_buffer<int>::iterator it1 = cb.begin() + 2; + circular_buffer<int>::iterator it2 = cb.begin() + 3; + circular_buffer<int>::iterator it3 = cb.begin() + 4; + circular_buffer<int>::iterator it4 = cb.begin() + 5; + + cb.rerase(cb.begin() + 2, cb.begin() + 4); + + // memory placement: { 2, 5, 6, X, X, 1 } + // circular buffer: { 1, 2, 5, 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() { + + // memory placement: { 3, 1, 2 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(3); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + + cb.linearize(); + + // memory placement: { 1, 2, 3 } + // circular buffer: { 1, 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() { + + // memory placement: { 3, 1, 2 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb1(3); + cb1.push_back(0); + cb1.push_back(1); + cb1.push_back(2); + cb1.push_back(3); + + // it11 -> 1, it12 -> 2, it13 -> 3 + circular_buffer<int>::iterator it11 = cb1.begin(); + circular_buffer<int>::iterator it12 = cb1.begin() + 1; + circular_buffer<int>::iterator it13 = cb1.begin() + 2; + + // memory placement: { 4, 5, 6 } + // circular buffer: { 4, 5, 6 } + circular_buffer<int> cb2(5); + cb2.push_back(4); + cb2.push_back(5); + cb2.push_back(6); + + // it21 -> 4, it22 -> 5, it23 -> 6 + circular_buffer<int>::iterator it21 = cb2.begin(); + circular_buffer<int>::iterator it22 = cb2.begin() + 1; + circular_buffer<int>::iterator it23 = cb2.begin() + 2; + + cb1.swap(cb2); + + // 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_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() { + + // memory placement: { 3, 1, 2 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(3); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + + cb.push_back(4); + + // memory placement: { 3, 4, 2 } + // circular buffer: { 2, 3, 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() { + + // memory placement: { 3, 1, 2 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(3); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + // it1 -> 1, it2 -> 2, it3 -> 3 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + circular_buffer<int>::iterator it3 = cb.begin() + 2; + + cb.push_front(4); + + // memory placement: { 4, 1, 2 } + // circular buffer: { 4, 1, 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() { + + // memory placement: { 3, 1, 2 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(3); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + // it1 -> 1, it2 -> 2 + circular_buffer<int>::iterator it1 = cb.begin(); + circular_buffer<int>::iterator it2 = cb.begin() + 1; + + cb.pop_back(); + + // memory placement: { X, 1, 2 } + // circular buffer: { 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() { + + // memory placement: { 3, 1, 2 } + // circular buffer: { 1, 2, 3 } + circular_buffer<int> cb(3); + cb.push_back(0); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + // it1 -> 2, it2 -> 3 + circular_buffer<int>::iterator it1 = cb.begin() + 1; + circular_buffer<int>::iterator it2 = cb.begin() + 2; + + cb.pop_front(); + + // memory placement: { 3, X, 2 } + // circular buffer: { 2, 3 } + BOOST_TEST(*it1 == 2); + BOOST_TEST(*it2 == 3); + BOOST_TEST(cb[0] == 2); + BOOST_TEST(cb[1] == 3); +} + +// test main +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(); +} diff --git a/src/boost/libs/circular_buffer/test/space_optimized_test.cpp b/src/boost/libs/circular_buffer/test/space_optimized_test.cpp new file mode 100644 index 000000000..8694fcdb7 --- /dev/null +++ b/src/boost/libs/circular_buffer/test/space_optimized_test.cpp @@ -0,0 +1,193 @@ +// Test of the space optimized adaptor of the circular buffer. + +// 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_space_optimized + +#include "common.ipp" + +typedef circular_buffer_space_optimized<MyInteger> cb_space_optimized; +typedef cb_space_optimized::capacity_type capacity_ctrl; + +// min_capacity test (it is useful to use a debug tool) +void min_capacity_test() { + + vector<int> v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + v.push_back(4); + v.push_back(5); + + cb_space_optimized cb1(capacity_ctrl(10, 10)); + cb_space_optimized cb2(capacity_ctrl(10, 5), 1); + cb_space_optimized cb3(capacity_ctrl(20, 10), v.begin(), v.end()); + + 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_TEST(cb2.size() == 2); + BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity()); + + cb2.clear(); + cb3.clear(); + + 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() { + + circular_buffer_space_optimized<int>::capacity_type c1 = 10; + circular_buffer_space_optimized<int>::capacity_type c2 = + circular_buffer_space_optimized<int>::capacity_type(20, 5); + circular_buffer_space_optimized<int>::capacity_type c3 = c2; + + 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_TEST(c1.capacity() == 20); + BOOST_TEST(c1.min_capacity() == 5); +} + +void specific_constructors_test() { + + cb_space_optimized cb1; + 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_TEST(cb1.size() == 0); + BOOST_TEST(cb1.capacity() == 0); + + vector<int> v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + + cb_space_optimized cb2(v.begin(), v.end()); + + BOOST_TEST(cb2.capacity() == 3); + BOOST_TEST(cb2.capacity().min_capacity() == 0); + BOOST_TEST(cb2.size() == 3); +} + +void shrink_to_fit_test() { + + cb_space_optimized cb(1000); + cb.push_back(1); + cb.push_back(2); + cb.push_back(3); + + BOOST_TEST(cb.size() == 3); + BOOST_TEST(cb.capacity() == 1000); + + size_t internal_capacity = cb.internal_capacity(); + cb_space_optimized(cb).swap(cb); + + BOOST_TEST(cb.size() == 3); + BOOST_TEST(cb.capacity() == 1000); + BOOST_TEST(internal_capacity >= cb.internal_capacity()); +} + +void iterator_invalidation_test() { + +#if BOOST_CB_ENABLE_DEBUG + + cb_space_optimized cb1(10, 1); + cb1.push_back(2); + cb1.push_back(3); + cb1.push_back(4); + cb_space_optimized::iterator it1 = cb1.end(); + cb_space_optimized::const_iterator it2 = cb1.begin(); + cb_space_optimized::iterator it3 = cb1.begin() + 6; + + cb1.set_capacity(10); + 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_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_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_TEST(it1.is_valid(&cb1)); + BOOST_TEST(!it2.is_valid(&cb1)); + BOOST_TEST(!it3.is_valid(&cb1)); + + { + cb_space_optimized cb2(10, 1); + cb2.push_back(2); + cb2.push_back(3); + cb2.push_back(4); + it1 = cb2.end(); + it2 = cb2.begin(); + it3 = cb2.begin() + 6; + } + 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 +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(); +} diff --git a/src/boost/libs/circular_buffer/test/test.hpp b/src/boost/libs/circular_buffer/test/test.hpp new file mode 100644 index 000000000..bbcc770ed --- /dev/null +++ b/src/boost/libs/circular_buffer/test/test.hpp @@ -0,0 +1,145 @@ +// Header file for the test of the circular buffer library. + +// 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) + +#if !defined(BOOST_CIRCULAR_BUFFER_TEST_HPP) +#define BOOST_CIRCULAR_BUFFER_TEST_HPP + +#if defined(_MSC_VER) && _MSC_VER >= 1200 + #pragma once +#endif + +#define BOOST_CB_TEST + +#include <boost/circular_buffer.hpp> +#include <boost/core/lightweight_test.hpp> +#include <iterator> +#include <numeric> +#include <vector> +#if !defined(BOOST_NO_EXCEPTIONS) + #include <exception> +#endif + +// Integer (substitute for int) - more appropriate for testing +class MyInteger { +private: + int* m_pValue; + static int ms_exception_trigger; + void check_exception() { + if (ms_exception_trigger > 0) { + if (--ms_exception_trigger == 0) { + delete m_pValue; + m_pValue = 0; +#if !defined(BOOST_NO_EXCEPTIONS) + throw std::exception(); +#endif + } + } + } +public: + MyInteger() : m_pValue(new int(0)) { check_exception(); } + MyInteger(int i) : m_pValue(new int(i)) { check_exception(); } + MyInteger(const MyInteger& src) : m_pValue(new int(src)) { check_exception(); } + ~MyInteger() { delete m_pValue; } + MyInteger& operator = (const MyInteger& src) { + if (this == &src) + return *this; + check_exception(); + delete m_pValue; + m_pValue = new int(src); + return *this; + } + operator int () const { return *m_pValue; } + static void set_exception_trigger(int n) { ms_exception_trigger = n; } +}; + +// default constructible class +class MyDefaultConstructible +{ +public: + MyDefaultConstructible() : m_n(1) {} + MyDefaultConstructible(int n) : m_n(n) {} + int m_n; +}; + +// class counting instances of self +class InstanceCounter { +public: + InstanceCounter() { increment(); } + InstanceCounter(const InstanceCounter& y) { y.increment(); } + ~InstanceCounter() { decrement(); } + static int count() { return ms_count; } +private: + void increment() const { ++ms_count; } + void decrement() const { --ms_count; } + static int ms_count; +}; + +// dummy class suitable for iterator referencing test +class Dummy { +public: + enum DummyEnum { + eVar, + eFnc, + eConst, + eVirtual + }; + Dummy() : m_n(eVar) {} + virtual ~Dummy() {} + DummyEnum fnc() { return eFnc; } + DummyEnum const_fnc() const { return eConst; } + virtual DummyEnum virtual_fnc() { return eVirtual; } + DummyEnum m_n; +}; + +// simulator of an input iterator +struct MyInputIterator { + typedef std::vector<int>::iterator vector_iterator; + typedef std::input_iterator_tag iterator_category; + typedef int value_type; + typedef int* pointer; + typedef int& reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + explicit MyInputIterator(const vector_iterator& it) : m_it(it) {} + MyInputIterator& operator = (const MyInputIterator& it) { + if (this == &it) + return *this; + m_it = it.m_it; + return *this; + } + reference operator * () const { return *m_it; } + pointer operator -> () const { return &(operator*()); } + MyInputIterator& operator ++ () { + ++m_it; + return *this; + } + MyInputIterator operator ++ (int) { + MyInputIterator tmp = *this; + ++*this; + return tmp; + } + bool operator == (const MyInputIterator& it) const { return m_it == it.m_it; } + bool operator != (const MyInputIterator& it) const { return m_it != it.m_it; } +private: + vector_iterator m_it; +}; + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) + +inline std::input_iterator_tag iterator_category(const MyInputIterator&) { + return std::input_iterator_tag(); +} +inline int* value_type(const MyInputIterator&) { return 0; } +inline ptrdiff_t* distance_type(const MyInputIterator&) { return 0; } + +#endif // #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) + +using namespace boost; +using namespace std; + +#endif // #if !defined(BOOST_CIRCULAR_BUFFER_TEST_HPP) |