Merge branch 'develop'

Replace broken sgi links.

.travis.yml

@@ -0,0 +1,234 @@
+# Copyright 2018 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: linux
+      compiler: clang++-6.0
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-6.0
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - mkdir -p libs/circular_buffer
+  - cp -r $TRAVIS_BUILD_DIR/* libs/circular_buffer
+  - python tools/boostdep/depinst/depinst.py circular_buffer
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j 3 libs/circular_buffer/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always

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)

appveyor.yml

@@ -0,0 +1,48 @@
+# Copyright 2018 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-10.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-11.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-12.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: 14,17
+
+install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\circular_buffer\
+  - python tools/boostdep/depinst/depinst.py circular_buffer
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - b2 -j 3 libs/circular_buffer/test toolset=%TOOLSET% %CXXSTD%

doc/circular_buffer.qbk

@@ -46,7 +46,7 @@
 [def __min_capacity [memberref boost::circular_buffer_space_optimized::min_capacity() min_capacity]]
 [def __capacity_control [memberref boost::circular_buffer_space_optimized::capacity_control () capacity_control ]]
 
-[def __debug_support  [link circular_buffer.implmentation.debug_support debug support]]
+[def __debug_support  [link circular_buffer.implementation.debug_support debug support]]
 
 [include ../../../tools/auto_index/include/auto_index_helpers.qbk]
 [/ Must be first included file!]
@@ -67,8 +67,8 @@ new data is written starting at the beginning of the buffer and overwriting the
 
 [classref boost::circular_buffer] is a STL compliant container.
 
-It is a kind of sequence similar to [@http://www.sgi.com/tech/stl/List.html std::list]
-or [@http://www.sgi.com/tech/stl/Deque.html std::deque].
+It is a kind of sequence similar to [@https://www.boost.org/sgi/stl/List.html std::list]
+or [@https://www.boost.org/sgi/stl/Deque.html std::deque].
 It supports random access iterators, constant time insert and erase operations
 at the beginning or the end of the buffer and interoperability with std algorithms.
 
@@ -114,7 +114,7 @@ Here is a simple example to introduce the class __cb.
 
 [circular_buffer_example_1]
 
-This example shows contruction, inserting elements, overwriting and popping.
+This example shows construction, inserting elements, overwriting and popping.
 
 [circular_buffer_example_2]
 
@@ -363,7 +363,7 @@ The __cb is compatible with the [@boost:libs/interprocess/index.html  Boost.Inte
 [/ This should be in @boost:libs/interprocess/doc/index.html ]
 library used for interprocess communication.
 Considering that the circular_buffer's debug support relies on 'raw' pointers
-(which is not permited by the Interprocess library)
+(which is not permitted by the Interprocess library)
 the code has to compiled with debug support disabled (i.e. with `BOOST_CB_ENABLE_DEBUG` macro not defined or defined to 0).
 Not doing that will cause the compilation to fail.
 
@@ -470,9 +470,9 @@ The __cbso is defined in the file [@boost:boost/circular_buffer/space_optimized.
 
 [section:concepts Modelled Concepts]
 
-[@http://www.sgi.com/tech/stl/RandomAccessContainer.html Random Access Container],
-[@http://www.sgi.com/tech/stl/FrontInsertionSequence.html Front Insertion Sequence], and
-[@http://www.sgi.com/tech/stl/BackInsertionSequence.html Back Insertion sequence]
+[@https://www.boost.org/sgi/stl/RandomAccessContainer.html Random Access Container],
+[@https://www.boost.org/sgi/stl/FrontInsertionSequence.html Front Insertion Sequence], and
+[@https://www.boost.org/sgi/stl/BackInsertionSequence.html Back Insertion sequence]
 
 [endsect] [/section:concepts Modelled Concepts]
 
@@ -483,10 +483,10 @@ The __cbso is defined in the file [@boost:boost/circular_buffer/space_optimized.
 [[T] [The type of the elements stored in the circular_buffer.
 The T has to be [@boost:libs/utility/Assignable.html Assignable]
 and [@boost:libs/utility/CopyConstructible.html CopyConstructible].
-Moreover T has to be [@http://www.sgi.com/tech/stl/DefaultConstructible.html DefaultConstructible]
+Moreover T has to be [@https://www.boost.org/sgi/stl/DefaultConstructible.html DefaultConstructible]
 if supplied as a default parameter when invoking some of the circular_buffer's methods,
 e.g. `insert(iterator pos, const value_type& item = value_type())`.
-And [@http://www.sgi.com/tech/stl/EqualityComparable.html EqualityComparable]
+And [@https://www.boost.org/sgi/stl/EqualityComparable.html EqualityComparable]
 and/or [@boost:libs/utility/LessThanComparable.html LessThanComparable]
 if the circular_buffer will be compared with another container.]]
 [[Alloc] [The allocator type used for all internal memory management.
@@ -538,7 +538,7 @@ Type: Patches
 
 [h4 Boost 1.56]
 
-* C++11 allocator model support implemented by Glen Fernandes using Boost allocator_traits.
+* C++11 allocator model support implemented by Glen Fernandes.
 
 [h4 Boost 1.55]
 

doc/jamfile.v2

@@ -29,8 +29,6 @@ doxygen autodoc
       [ glob ../../../boost/circular_buffer.hpp ]
       [ glob ../../../boost/circular_buffer/base.hpp ]
       [ glob ../../../boost/circular_buffer/space_optimized.hpp ]
-      [ glob ../../../boost/circular_buffer/details.hpp ] # Needed for capacity_control at least.
-      [ glob ../../../boost/circular_buffer/debug.hpp ] # not needed?
       
    :
    # Pass some setting parameters to Doxygen.
@@ -83,8 +81,8 @@ doxygen autodoc
      
       # The syntax hoops to jump through are 'interesting' for more than one PREDEFINED,
       # and to permit spaces within definitions (use double quotes).
-      # Don't forget that every double quote " needs a preceeding \trip character!
-      # and that each trailing continuation \ needs a preceeding \trip character too!
+      # Don't forget that every double quote " needs a preceding \trip character!
+      # and that each trailing continuation \ needs a preceding \trip character too!
       # And finally that if more than one item is included (as here) the whole is
       # enclosed in "PREDEFINED=... ", but without a leading \.  Go figure...
       

example/bounded_buffer_comparison.cpp

@@ -11,8 +11,8 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
+#include <boost/timer/timer.hpp>
 #include <boost/call_traits.hpp>
-#include <boost/progress.hpp>
 #include <boost/bind.hpp>
 #include <deque>
 #include <list>
@@ -229,7 +229,7 @@ template<class Buffer>
 void fifo_test(Buffer* buffer) {
 
     // Start of measurement
-    boost::progress_timer progress;
+    boost::timer::auto_cpu_timer progress;
 
     // Initialize the buffer with some values before launching producer and consumer threads.
     for (unsigned long i = QUEUE_SIZE / 2L; i > 0; --i) {

example/circular_buffer_bound_example.cpp

@@ -19,6 +19,7 @@ as an underlying container of the bounded buffer.
 #include <boost/bind.hpp>
 
 #include <boost/timer/timer.hpp> // for auto_cpu_timer
+#include <iostream>
 
 template <class T>
 class bounded_buffer

example/circular_buffer_example.cpp

@@ -20,7 +20,7 @@
     // Create a circular buffer with a capacity for 3 integers.
     boost::circular_buffer<int> cb(3);
 
-    // Insert threee elements into the buffer.
+    // Insert three elements into the buffer.
     cb.push_back(1);
     cb.push_back(2);
     cb.push_back(3);

example/circular_buffer_examples.bat

@@ -1,5 +1,5 @@
 echo off
-rem quickbook doxgen auto-index docs template circular_buffer_html_index.bat
+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

example/jamfile.v2

@@ -35,7 +35,7 @@ project
       <toolset>msvc:<cxxflags>/wd4305
     ;
     
-run bounded_buffer_comparison.cpp ;
+run bounded_buffer_comparison.cpp ../../timer/build//boost_timer ;
 run circular_buffer_iter_example.cpp ;
 run circular_buffer_sum_example.cpp ;
 run circular_buffer_bound_example.cpp ../../thread/build//boost_thread ../../timer/build//boost_timer ;

include/boost/circular_buffer.hpp

@@ -8,6 +8,10 @@
 
 //  See www.boost.org/libs/circular_buffer for documentation.
 
+/*! @file
+Includes <boost/circular_buffer/base.hpp>
+*/
+
 #if !defined(BOOST_CIRCULAR_BUFFER_HPP)
 #define BOOST_CIRCULAR_BUFFER_HPP
 
@@ -16,15 +20,15 @@
 #endif
 
 #include <boost/circular_buffer_fwd.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/static_assert.hpp>
 
-// BOOST_CB_ENABLE_DEBUG: Debug support control.
+/*! Debug support control. */
 #if !defined(BOOST_CB_ENABLE_DEBUG)
     #define BOOST_CB_ENABLE_DEBUG 0
 #endif
 
-// BOOST_CB_ASSERT: Runtime assertion.
+/*! INTERNAL ONLY */
 #if BOOST_CB_ENABLE_DEBUG
     #include <boost/assert.hpp>
     #define BOOST_CB_ASSERT(Expr) BOOST_ASSERT(Expr)
@@ -32,18 +36,17 @@
     #define BOOST_CB_ASSERT(Expr) ((void)0)
 #endif
 
-// BOOST_CB_IS_CONVERTIBLE: Check if Iterator::value_type is convertible to Type.
+/*! INTERNAL ONLY */
 #if BOOST_WORKAROUND(__BORLANDC__, <= 0x0550) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
     #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) ((void)0)
 #else
-    #include <boost/detail/iterator.hpp>
+    #include <iterator>
     #include <boost/type_traits/is_convertible.hpp>
     #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) \
-        BOOST_STATIC_ASSERT((is_convertible<typename detail::iterator_traits<Iterator>::value_type, Type>::value))
+        BOOST_STATIC_ASSERT((is_convertible<typename std::iterator_traits<Iterator>::value_type, Type>::value))
 #endif
 
-// BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS:
-// Check if the STL provides templated iterator constructors for its containers.
+/*! INTERNAL ONLY */
 #if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
     #define BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS BOOST_STATIC_ASSERT(false);
 #else

include/boost/circular_buffer/allocators.hpp

@@ -0,0 +1,89 @@
+// Copyright 2018 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
+//
+// 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)
+
+#ifndef BOOST_CIRCULAR_BUFFER_ALLOCATORS_HPP
+#define BOOST_CIRCULAR_BUFFER_ALLOCATORS_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+#define BOOST_CB_NO_CXX11_ALLOCATOR
+#elif defined(BOOST_LIBSTDCXX_VERSION) && (BOOST_LIBSTDCXX_VERSION < 40800)
+#define BOOST_CB_NO_CXX11_ALLOCATOR
+#endif
+#include <limits>
+#if !defined(BOOST_CB_NO_CXX11_ALLOCATOR)
+#include <memory>
+#else
+#include <new>
+#endif
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#include <utility>
+#endif
+
+namespace boost {
+namespace cb_details {
+
+#if !defined(BOOST_CB_NO_CXX11_ALLOCATOR)
+template<class A>
+struct allocator_traits
+    : std::allocator_traits<A> {
+    using typename std::allocator_traits<A>::value_type;
+    using typename std::allocator_traits<A>::size_type;
+
+    static size_type max_size(const A&) BOOST_NOEXCEPT {
+        return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
+    }
+};
+#else
+template<class A>
+struct allocator_traits {
+    typedef typename A::value_type value_type;
+    typedef typename A::pointer pointer;
+    typedef typename A::const_pointer const_pointer;
+    typedef typename A::difference_type difference_type;
+    typedef typename A::size_type size_type;
+
+    static size_type max_size(const A&) BOOST_NOEXCEPT {
+        return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
+    }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template<class U, class... Args>
+    static void construct(const A&, U* ptr, Args&&... args) {
+        ::new((void*)ptr) U(std::forward<Args>(args)...);
+    }
+#else
+    template<class U, class V>
+    static void construct(const A&, U* ptr, V&& value) {
+        ::new((void*)ptr) U(std::forward<V>(value));
+    }
+#endif
+#else
+    template<class U, class V>
+    static void construct(const A&, U* ptr, const V& value) {
+        ::new((void*)ptr) U(value);
+    }
+
+    template<class U, class V>
+    static void construct(const A&, U* ptr, V& value) {
+        ::new((void*)ptr) U(value);
+    }
+#endif
+
+    template<class U>
+    static void destroy(const A&, U* ptr) {
+        (void)ptr;
+        ptr->~U();
+    }
+};
+#endif
+
+} // cb_details
+} // boost
+
+#endif

include/boost/circular_buffer/details.hpp

@@ -1,7 +1,9 @@
 // Helper classes and functions for the circular buffer.
 
 // Copyright (c) 2003-2008 Jan Gaspar
-// Copyright (c) 2014 Glen Joseph Fernandes   // C++11 allocator model support.
+
+// 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
@@ -15,12 +17,11 @@
 #endif
 
 #include <boost/throw_exception.hpp>
-#include <boost/container/allocator_traits.hpp>
+#include <boost/circular_buffer/allocators.hpp>
 #include <boost/core/pointer_traits.hpp>
 #include <boost/move/move.hpp>
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 #include <iterator>
 
 // Silence MS /W4 warnings like C4913:
@@ -35,13 +36,6 @@ namespace boost {
 
 namespace cb_details {
 
-template<class Pointer>
-inline typename boost::pointer_traits<Pointer>::element_type*
-to_address(Pointer p) BOOST_NOEXCEPT
-{
-    return  boost::pointer_traits<Pointer>::to_address(p);
-}
-
 template <class Traits> struct nonconst_traits;
 
 template<class ForwardIterator, class Diff, class T, class Alloc>
@@ -63,7 +57,7 @@ struct const_traits {
     // Basic types
     typedef typename Traits::value_type value_type;
     typedef typename Traits::const_pointer pointer;
-    typedef typename Traits::const_reference reference;
+    typedef const value_type& reference;
     typedef typename Traits::size_type size_type;
     typedef typename Traits::difference_type difference_type;
 
@@ -80,7 +74,7 @@ struct nonconst_traits {
     // Basic types
     typedef typename Traits::value_type value_type;
     typedef typename Traits::pointer pointer;
-    typedef typename Traits::reference reference;
+    typedef value_type& reference;
     typedef typename Traits::size_type size_type;
     typedef typename Traits::difference_type difference_type;
 
@@ -120,7 +114,7 @@ private:
 */
 template <class Value, class Alloc>
 struct assign_n {
-    typedef typename boost::container::allocator_traits<Alloc>::size_type size_type;
+    typedef typename allocator_traits<Alloc>::size_type size_type;
     size_type m_n;
     Value m_item;
     Alloc& m_alloc;
@@ -202,46 +196,33 @@ public:
           for iterating from begin() to end() of the circular buffer.
 */
 template <class Buff, class Traits>
-struct iterator :
-    public std::iterator<
-    std::random_access_iterator_tag,
-    typename Traits::value_type,
-    typename Traits::difference_type,
-    typename Traits::pointer,
-    typename Traits::reference>
+struct iterator
 #if BOOST_CB_ENABLE_DEBUG
-    , public debug_iterator_base
+    : public debug_iterator_base
 #endif // #if BOOST_CB_ENABLE_DEBUG
 {
 // Helper types
 
-    //! Base iterator.
-    typedef std::iterator<
-        std::random_access_iterator_tag,
-        typename Traits::value_type,
-        typename Traits::difference_type,
-        typename Traits::pointer,
-        typename Traits::reference> base_iterator;
-
     //! Non-const iterator.
     typedef iterator<Buff, typename Traits::nonconst_self> nonconst_self;
 
 // Basic types
+    typedef std::random_access_iterator_tag iterator_category;
 
     //! The type of the elements stored in the circular buffer.
-    typedef typename base_iterator::value_type value_type;
+    typedef typename Traits::value_type value_type;
 
     //! Pointer to the element.
-    typedef typename base_iterator::pointer pointer;
+    typedef typename Traits::pointer pointer;
 
     //! Reference to the element.
-    typedef typename base_iterator::reference reference;
+    typedef typename Traits::reference reference;
 
     //! Size type.
     typedef typename Traits::size_type size_type;
 
     //! Difference type.
-    typedef typename base_iterator::difference_type difference_type;
+    typedef typename Traits::difference_type difference_type;
 
 // Member variables
 
@@ -443,10 +424,10 @@ inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator las
     ForwardIterator next = dest;
     BOOST_TRY {
         for (; first != last; ++first, ++dest)
-            boost::container::allocator_traits<Alloc>::construct(a, cb_details::to_address(dest), *first);
+            allocator_traits<Alloc>::construct(a, boost::to_address(dest), *first);
     } BOOST_CATCH(...) {
         for (; next != dest; ++next)
-            boost::container::allocator_traits<Alloc>::destroy(a, cb_details::to_address(next));
+            allocator_traits<Alloc>::destroy(a, boost::to_address(next));
         BOOST_RETHROW
     }
     BOOST_CATCH_END
@@ -457,7 +438,7 @@ template<class InputIterator, class ForwardIterator, class Alloc>
 ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a,
     true_type) {
     for (; first != last; ++first, ++dest)
-        boost::container::allocator_traits<Alloc>::construct(a, cb_details::to_address(dest), boost::move(*first));
+        allocator_traits<Alloc>::construct(a, boost::to_address(dest), boost::move(*first));
     return dest;
 }
 
@@ -473,7 +454,7 @@ ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIt
 */
 template<class InputIterator, class ForwardIterator, class Alloc>
 ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) {
-    typedef typename boost::is_nothrow_move_constructible<typename boost::container::allocator_traits<Alloc>::value_type>::type tag_t;
+    typedef typename boost::is_nothrow_move_constructible<typename allocator_traits<Alloc>::value_type>::type tag_t;
     return uninitialized_move_if_noexcept_impl(first, last, dest, a, tag_t());
 }
 
@@ -486,10 +467,10 @@ inline void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const
     ForwardIterator next = first;
     BOOST_TRY {
         for (; n > 0; ++first, --n)
-            boost::container::allocator_traits<Alloc>::construct(alloc, cb_details::to_address(first), item);
+            allocator_traits<Alloc>::construct(alloc, boost::to_address(first), item);
     } BOOST_CATCH(...) {
         for (; next != first; ++next)
-            boost::container::allocator_traits<Alloc>::destroy(alloc, cb_details::to_address(next));
+            allocator_traits<Alloc>::destroy(alloc, boost::to_address(next));
         BOOST_RETHROW
     }
     BOOST_CATCH_END

include/boost/circular_buffer/space_optimized.hpp

@@ -16,7 +16,7 @@
 #endif
 
 #include <boost/type_traits/is_same.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 namespace boost {
 
@@ -453,7 +453,7 @@ public:
     /*!
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity().%capacity() == std::distance(first, last) \&\& capacity().min_capacity() == 0 \&\&
               full() \&\& (*this)[0]== *first \&\& (*this)[1] == *(first + 1) \&\& ... \&\&
               (*this)[std::distance(first, last) - 1] == *(last - 1)</code><br><br>
@@ -478,7 +478,7 @@ public:
                of allocated memory) filled with a copy of the range.
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity() == capacity_ctrl \&\& size() \<= std::distance(first, last) \&\& (*this)[0]==
               *(last - capacity_ctrl.%capacity()) \&\& (*this)[1] == *(last - capacity_ctrl.%capacity() + 1) \&\& ...
               \&\& (*this)[capacity_ctrl.%capacity() - 1] == *(last - 1)</code><br><br>
@@ -499,7 +499,7 @@ public:
         \par Complexity
              Linear (in <code>std::distance(first, last)</code>; in
              <code>min[capacity_ctrl.%capacity(), std::distance(first, last)]</code> if the <code>InputIterator</code>
-             is a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             is a <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
     */
     template <class InputIterator>
     circular_buffer_space_optimized(capacity_type capacity_ctrl, InputIterator first, InputIterator last,
@@ -509,7 +509,7 @@ public:
         first, last, alloc)
     , m_capacity_ctrl(capacity_ctrl) {
         reduce_capacity(
-            is_same< BOOST_DEDUCED_TYPENAME iterator_category<InputIterator>::type, std::input_iterator_tag >());
+            is_same< BOOST_DEDUCED_TYPENAME std::iterator_traits<InputIterator>::iterator_category, std::input_iterator_tag >());
     }
 
 #if defined(BOOST_CB_NEVER_DEFINED)
@@ -579,7 +579,7 @@ public:
     */
     circular_buffer_space_optimized<T, Alloc>& operator = (circular_buffer_space_optimized<T, Alloc>&& cb) BOOST_NOEXCEPT {
         cb.swap(*this); // now `this` holds `cb`
-        circular_buffer<T, Alloc>(get_allocator()) // temprary that holds initial `cb` allocator
+        circular_buffer<T, Alloc>(get_allocator()) // temporary that holds initial `cb` allocator
             .swap(cb); // makes `cb` empty
         return *this;
     }
@@ -655,7 +655,7 @@ public:
         elements from the specified range.
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity().%capacity() == std::distance(first, last) \&\& capacity().min_capacity() == 0 \&\&
               size() == std::distance(first, last) \&\& (*this)[0]== *first \&\& (*this)[1] == *(first + 1) \&\& ...
               \&\& (*this)[std::distance(first, last) - 1] == *(last - 1)</code><br><br>
@@ -692,7 +692,7 @@ public:
         elements from the specified range.
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity() == capacity_ctrl \&\& size() \<= std::distance(first, last) \&\&
              (*this)[0]== *(last - capacity) \&\& (*this)[1] == *(last - capacity + 1) \&\& ... \&\&
              (*this)[capacity - 1] == *(last - 1)</code><br><br>
@@ -715,7 +715,7 @@ public:
         \par Complexity
              Linear (in <code>std::distance(first, last)</code>; in
              <code>min[capacity_ctrl.%capacity(), std::distance(first, last)]</code> if the <code>InputIterator</code>
-             is a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             is a <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \sa <code>\link operator=(const circular_buffer_space_optimized&) operator=\endlink</code>,
             <code>\link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink</code>,
             <code>\link assign(capacity_type, size_type, param_value_type)
@@ -1114,7 +1114,7 @@ public:
     /*!
         \pre <code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or its
              end.<br>Valid range <code>[first, last)</code> where <code>first</code> and <code>last</code> meet the
-             requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             requirements of an <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post Elements from the range
               <code>[first + max[0, distance(first, last) - (pos - begin()) - reserve()], last)</code> will be
               inserted at the position <code>pos</code>.<br>The number of <code>min[pos - begin(), max[0,
@@ -1136,7 +1136,7 @@ public:
              Linear (in <code>[size() + std::distance(first, last)]</code>; in
              <code>min[capacity().%capacity(), size() + std::distance(first, last)]</code> if the
              <code>InputIterator</code> is a
-             <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \par Example
              Consider a <code>circular_buffer_space_optimized</code> with the capacity of 6 and the size of 4. Its
              internal buffer may look like the one below.<br><br>
@@ -1326,7 +1326,7 @@ public:
         \pre <code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or its
              end.<br>
              Valid range <code>[first, last)</code> where <code>first</code> and <code>last</code> meet the
-             requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             requirements of an <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post Elements from the range
               <code>[first, last - max[0, distance(first, last) - (end() - pos) - reserve()])</code> will be inserted
               before the position <code>pos</code>.<br>The number of <code>min[end() - pos, max[0,
@@ -1349,7 +1349,7 @@ public:
              Linear (in <code>[size() + std::distance(first, last)]</code>; in
              <code>min[capacity().%capacity(), size() + std::distance(first, last)]</code> if the
              <code>InputIterator</code> is a
-             <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \par Example
              Consider a <code>circular_buffer_space_optimized</code> with the capacity of 6 and the size of 4. Its
              internal buffer may look like the one below.<br><br>
@@ -1522,7 +1522,7 @@ public:
 private:
 // Helper methods
 
-    //! Adjust the amount of allocated memory.
+    /*! INTERNAL ONLY */
     void adjust_min_capacity() {
         if (m_capacity_ctrl.min_capacity() > circular_buffer<T, Alloc>::capacity())
             circular_buffer<T, Alloc>::set_capacity(m_capacity_ctrl.min_capacity());
@@ -1530,7 +1530,7 @@ private:
             check_high_capacity();
     }
 
-    //! Ensure the reserve for possible growth up.
+    /*! INTERNAL ONLY */
     size_type ensure_reserve(size_type new_capacity, size_type buffer_size) const {
         if (buffer_size + new_capacity / 5 >= new_capacity)
             new_capacity *= 2; // ensure at least 20% reserve
@@ -1539,10 +1539,7 @@ private:
         return new_capacity;
     }
 
-    //! Check for low capacity.
-    /*
-        \post If the capacity is low it will be increased.
-    */
+    /*! INTERNAL ONLY */
     void check_low_capacity(size_type n = 1) {
         size_type new_size = size() + n;
         size_type new_capacity = circular_buffer<T, Alloc>::capacity();
@@ -1558,10 +1555,7 @@ private:
 #endif
     }
 
-    //! Check for high capacity.
-    /*
-        \post If the capacity is high it will be decreased.
-    */
+    /*! INTERNAL ONLY */
     void check_high_capacity() {
         size_type new_capacity = circular_buffer<T, Alloc>::capacity();
         while (new_capacity / 3 >= size()) { // (new_capacity / 3) -> avoid oscillations
@@ -1578,48 +1572,48 @@ private:
 #endif
     }
 
-    //! Specialized method for reducing the capacity.
+    /*! INTERNAL ONLY */
     void reduce_capacity(const true_type&) {
         circular_buffer<T, Alloc>::set_capacity((std::max)(m_capacity_ctrl.min_capacity(), size()));
     }
 
-    //! Specialized method for reducing the capacity.
+    /*! INTERNAL ONLY */
     void reduce_capacity(const false_type&) {}
 
-    //! Determine the initial capacity.
+    /*! INTERNAL ONLY */
     static size_type init_capacity(const capacity_type& capacity_ctrl, size_type n) {
         BOOST_CB_ASSERT(capacity_ctrl.capacity() >= n); // check for capacity lower than n
         return (std::max)(capacity_ctrl.min_capacity(), n);
     }
 
-    //! Specialized method for determining the initial capacity.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     static size_type init_capacity(const capacity_type& capacity_ctrl, IntegralType n, IntegralType,
         const true_type&) {
         return init_capacity(capacity_ctrl, static_cast<size_type>(n));
     }
 
-    //! Specialized method for determining the initial capacity.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     static size_type init_capacity(const capacity_type& capacity_ctrl, Iterator first, Iterator last,
         const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
-        return init_capacity(capacity_ctrl, first, last, iterator_category<Iterator>::type());
+        return init_capacity(capacity_ctrl, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         return init_capacity(
-            capacity_ctrl, first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+            capacity_ctrl, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
-    //! Specialized method for determining the initial capacity.
+    /*! INTERNAL ONLY */
     template <class InputIterator>
     static size_type init_capacity(const capacity_type& capacity_ctrl, InputIterator, InputIterator,
         const std::input_iterator_tag&) {
         return capacity_ctrl.capacity();
     }
 
-    //! Specialized method for determining the initial capacity.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     static size_type init_capacity(const capacity_type& capacity_ctrl, ForwardIterator first, ForwardIterator last,
         const std::forward_iterator_tag&) {
@@ -1628,13 +1622,13 @@ private:
             (std::min)(capacity_ctrl.capacity(), static_cast<size_type>(std::distance(first, last))));
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
         insert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
         size_type index = pos - begin();
@@ -1642,13 +1636,13 @@ private:
         circular_buffer<T, Alloc>::insert(begin() + index, first, last);
     }
 
-    //! Specialized rinsert method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
         rinsert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
     }
 
-    //! Specialized rinsert method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
         size_type index = pos - begin();

test/base_test.cpp

@@ -25,11 +25,11 @@ void iterator_constructor_and_assign_test() {
     circular_buffer<MyInteger>::const_iterator end1 = cb.end();
     circular_buffer<MyInteger>::const_iterator end2 = end1;
 
-    BOOST_CHECK(itCopy == it);
-    BOOST_CHECK(cit == it);
-    BOOST_CHECK(end1 == end2);
-    BOOST_CHECK(it != end1);
-    BOOST_CHECK(cit != end2);
+    BOOST_TEST(itCopy == it);
+    BOOST_TEST(cit == it);
+    BOOST_TEST(end1 == end2);
+    BOOST_TEST(it != end1);
+    BOOST_TEST(cit != end2);
 }
 
 void iterator_reference_test() {
@@ -38,14 +38,14 @@ void iterator_reference_test() {
     circular_buffer<Dummy>::iterator it = cb.begin();
     circular_buffer<Dummy>::const_iterator cit = cb.begin() + 1;
 
-    BOOST_CHECK((*it).m_n == Dummy::eVar);
-    BOOST_CHECK((*it).fnc() == Dummy::eFnc);
-    BOOST_CHECK((*cit).const_fnc() == Dummy::eConst);
-    BOOST_CHECK((*it).virtual_fnc() == Dummy::eVirtual);
-    BOOST_CHECK(it->m_n == Dummy::eVar);
-    BOOST_CHECK(it->fnc() == Dummy::eFnc);
-    BOOST_CHECK(cit->const_fnc() == Dummy::eConst);
-    BOOST_CHECK(it->virtual_fnc() == Dummy::eVirtual);
+    BOOST_TEST((*it).m_n == Dummy::eVar);
+    BOOST_TEST((*it).fnc() == Dummy::eFnc);
+    BOOST_TEST((*cit).const_fnc() == Dummy::eConst);
+    BOOST_TEST((*it).virtual_fnc() == Dummy::eVirtual);
+    BOOST_TEST(it->m_n == Dummy::eVar);
+    BOOST_TEST(it->fnc() == Dummy::eFnc);
+    BOOST_TEST(cit->const_fnc() == Dummy::eConst);
+    BOOST_TEST(it->virtual_fnc() == Dummy::eVirtual);
 }
 
 void iterator_difference_test() {
@@ -57,16 +57,16 @@ void iterator_difference_test() {
     circular_buffer<MyInteger>::const_iterator begin = cb.begin();
     circular_buffer<MyInteger>::iterator end = cb.end();
 
-    BOOST_CHECK(begin - begin == 0);
-    BOOST_CHECK(end - cb.begin() == 5);
-    BOOST_CHECK(end - end == 0);
-    BOOST_CHECK(begin - cb.end() == -5);
-    BOOST_CHECK(it1 - cb.begin() == 2);
-    BOOST_CHECK(it1 - begin == 2);
-    BOOST_CHECK(end - it1 == 3);
-    BOOST_CHECK(it2 - it1 == 1);
-    BOOST_CHECK(it1 - it2 == -1);
-    BOOST_CHECK(it2 - it2 == 0);
+    BOOST_TEST(begin - begin == 0);
+    BOOST_TEST(end - cb.begin() == 5);
+    BOOST_TEST(end - end == 0);
+    BOOST_TEST(begin - cb.end() == -5);
+    BOOST_TEST(it1 - cb.begin() == 2);
+    BOOST_TEST(it1 - begin == 2);
+    BOOST_TEST(end - it1 == 3);
+    BOOST_TEST(it2 - it1 == 1);
+    BOOST_TEST(it1 - it2 == -1);
+    BOOST_TEST(it2 - it2 == 0);
 }
 
 void iterator_increment_test() {
@@ -80,9 +80,9 @@ void iterator_increment_test() {
     it2++;
     ++it3;
 
-    BOOST_CHECK(it1 == cb.begin() + 1);
-    BOOST_CHECK(it2 == cb.begin() + 6);
-    BOOST_CHECK(it3 == cb.end());
+    BOOST_TEST(it1 == cb.begin() + 1);
+    BOOST_TEST(it2 == cb.begin() + 6);
+    BOOST_TEST(it3 == cb.end());
 }
 
 void iterator_decrement_test() {
@@ -96,9 +96,9 @@ void iterator_decrement_test() {
     it2--;
     --it3;
 
-    BOOST_CHECK(it1 == cb.end() - 1);
-    BOOST_CHECK(it2 == cb.end() - 6);
-    BOOST_CHECK(it3 == cb.begin());
+    BOOST_TEST(it1 == cb.end() - 1);
+    BOOST_TEST(it2 == cb.end() - 6);
+    BOOST_TEST(it3 == cb.begin());
 }
 
 void iterator_addition_test() {
@@ -115,12 +115,12 @@ void iterator_addition_test() {
     it3 += 5;
     it4 += -2;
 
-    BOOST_CHECK(it1 == 5 + cb.begin());
-    BOOST_CHECK(it2 == cb.end());
-    BOOST_CHECK(it3 == cb.end());
-    BOOST_CHECK(it4 + 3 == cb.end());
-    BOOST_CHECK((-3) + it4 == cb.begin() + 4);
-    BOOST_CHECK(cb.begin() + 0 == cb.begin());
+    BOOST_TEST(it1 == 5 + cb.begin());
+    BOOST_TEST(it2 == cb.end());
+    BOOST_TEST(it3 == cb.end());
+    BOOST_TEST(it4 + 3 == cb.end());
+    BOOST_TEST((-3) + it4 == cb.begin() + 4);
+    BOOST_TEST(cb.begin() + 0 == cb.begin());
 }
 
 void iterator_subtraction_test() {
@@ -137,12 +137,12 @@ void iterator_subtraction_test() {
     it2 -= 0;
     it3 -= 5;
 
-    BOOST_CHECK(it1 == cb.begin() + 2);
-    BOOST_CHECK(it2 == cb.end());
-    BOOST_CHECK(it3 == cb.begin());
-    BOOST_CHECK(it4 - 7 == cb.begin());
-    BOOST_CHECK(it4 - (-3) == cb.end());
-    BOOST_CHECK(cb.begin() - 0 == cb.begin());
+    BOOST_TEST(it1 == cb.begin() + 2);
+    BOOST_TEST(it2 == cb.end());
+    BOOST_TEST(it3 == cb.begin());
+    BOOST_TEST(it4 - 7 == cb.begin());
+    BOOST_TEST(it4 - (-3) == cb.end());
+    BOOST_TEST(cb.begin() - 0 == cb.begin());
 }
 
 void iterator_element_access_test() {
@@ -156,9 +156,9 @@ void iterator_element_access_test() {
     cb.push_back(6);
     circular_buffer<MyInteger>::iterator it = cb.begin() + 1;
 
-    BOOST_CHECK(it[0] == 2);
-    BOOST_CHECK(it[-1] == 1);
-    BOOST_CHECK(it[2] == 4);
+    BOOST_TEST(it[0] == 2);
+    BOOST_TEST(it[-1] == 1);
+    BOOST_TEST(it[2] == 4);
 }
 
 void iterator_comparison_test() {
@@ -169,26 +169,26 @@ void iterator_comparison_test() {
     circular_buffer<MyInteger>::const_iterator begin = cb.begin();
     circular_buffer<MyInteger>::iterator end = cb.end();
 
-    BOOST_CHECK(begin == begin);
-    BOOST_CHECK(end > cb.begin());
-    BOOST_CHECK(begin < end);
-    BOOST_CHECK(end > begin);
-    BOOST_CHECK(end == end);
-    BOOST_CHECK(begin < cb.end());
-    BOOST_CHECK(!(begin + 1 > cb.end()));
-    BOOST_CHECK(it > cb.begin());
-    BOOST_CHECK(end > it);
-    BOOST_CHECK(begin >= begin);
-    BOOST_CHECK(end >= cb.begin());
-    BOOST_CHECK(end <= end);
-    BOOST_CHECK(begin <= cb.end());
-    BOOST_CHECK(it >= cb.begin());
-    BOOST_CHECK(end >= it);
-    BOOST_CHECK(!(begin + 4 < begin + 4));
-    BOOST_CHECK(begin + 4 < begin + 5);
-    BOOST_CHECK(!(begin + 5 < begin + 4));
-    BOOST_CHECK(it < end - 1);
-    BOOST_CHECK(!(end - 1 < it));
+    BOOST_TEST(begin == begin);
+    BOOST_TEST(end > cb.begin());
+    BOOST_TEST(begin < end);
+    BOOST_TEST(end > begin);
+    BOOST_TEST(end == end);
+    BOOST_TEST(begin < cb.end());
+    BOOST_TEST(!(begin + 1 > cb.end()));
+    BOOST_TEST(it > cb.begin());
+    BOOST_TEST(end > it);
+    BOOST_TEST(begin >= begin);
+    BOOST_TEST(end >= cb.begin());
+    BOOST_TEST(end <= end);
+    BOOST_TEST(begin <= cb.end());
+    BOOST_TEST(it >= cb.begin());
+    BOOST_TEST(end >= it);
+    BOOST_TEST(!(begin + 4 < begin + 4));
+    BOOST_TEST(begin + 4 < begin + 5);
+    BOOST_TEST(!(begin + 5 < begin + 4));
+    BOOST_TEST(it < end - 1);
+    BOOST_TEST(!(end - 1 < it));
 }
 
 void iterator_invalidation_test() {
@@ -202,12 +202,12 @@ void iterator_invalidation_test() {
     circular_buffer<MyInteger>::const_iterator it5;
     circular_buffer<MyInteger>::const_iterator it6;
 
-    BOOST_CHECK(it1.is_valid(0));
-    BOOST_CHECK(it2.is_valid(0));
-    BOOST_CHECK(it3.is_valid(0));
-    BOOST_CHECK(it4.is_valid(0));
-    BOOST_CHECK(it5.is_valid(0));
-    BOOST_CHECK(it6.is_valid(0));
+    BOOST_TEST(it1.is_valid(0));
+    BOOST_TEST(it2.is_valid(0));
+    BOOST_TEST(it3.is_valid(0));
+    BOOST_TEST(it4.is_valid(0));
+    BOOST_TEST(it5.is_valid(0));
+    BOOST_TEST(it6.is_valid(0));
 
     {
         circular_buffer<MyInteger> cb(5, 0);
@@ -220,49 +220,49 @@ void iterator_invalidation_test() {
         it5 = it2;
         it6 = it1;
 
-        BOOST_CHECK(it1.is_valid(&cb));
-        BOOST_CHECK(it2.is_valid(&ccb));
-        BOOST_CHECK(it3.is_valid(&cb));
-        BOOST_CHECK(it4.is_valid(&cb));
-        BOOST_CHECK(it5.is_valid(&ccb));
-        BOOST_CHECK(it6.is_valid(&cb));
+        BOOST_TEST(it1.is_valid(&cb));
+        BOOST_TEST(it2.is_valid(&ccb));
+        BOOST_TEST(it3.is_valid(&cb));
+        BOOST_TEST(it4.is_valid(&cb));
+        BOOST_TEST(it5.is_valid(&ccb));
+        BOOST_TEST(it6.is_valid(&cb));
     }
 
-    BOOST_CHECK(it1.is_valid(0));
-    BOOST_CHECK(it2.is_valid(0));
-    BOOST_CHECK(it3.is_valid(0));
-    BOOST_CHECK(it4.is_valid(0));
-    BOOST_CHECK(it5.is_valid(0));
-    BOOST_CHECK(it6.is_valid(0));
+    BOOST_TEST(it1.is_valid(0));
+    BOOST_TEST(it2.is_valid(0));
+    BOOST_TEST(it3.is_valid(0));
+    BOOST_TEST(it4.is_valid(0));
+    BOOST_TEST(it5.is_valid(0));
+    BOOST_TEST(it6.is_valid(0));
 
     circular_buffer<MyInteger> cb(10, 0);
     it1 = cb.end();
     cb.clear();
-    BOOST_CHECK(it1.is_valid(&cb));
+    BOOST_TEST(it1.is_valid(&cb));
     cb.push_back(1);
     cb.push_back(2);
     cb.push_back(3);
     int i = 0;
     for (it2 = cb.begin(); it2 != it1; it2++, i++);
-    BOOST_CHECK(i == 3);
+    BOOST_TEST(i == 3);
 
     circular_buffer<MyInteger> cb1(10, 0);
     circular_buffer<MyInteger> cb2(20, 0);
     it1 = cb1.end();
     it2 = cb2.begin();
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(it2.is_valid(&cb2));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(it2.is_valid(&cb2));
 
     cb1.swap(cb2);
-    BOOST_CHECK(!it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb2));
+    BOOST_TEST(!it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb2));
 
     it1 = cb1.begin() + 3;
     it2 = cb1.begin();
     cb1.push_back(1);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(*it2.m_it == 1);
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(*it2.m_it == 1);
 
     circular_buffer<MyInteger> cb3(5);
     cb3.push_back(1);
@@ -273,16 +273,16 @@ void iterator_invalidation_test() {
     it1 = cb3.begin() + 2;
     it2 = cb3.begin();
     cb3.insert(cb3.begin() + 3, 6);
-    BOOST_CHECK(it1.is_valid(&cb3));
-    BOOST_CHECK(!it2.is_valid(&cb3));
-    BOOST_CHECK(*it2.m_it == 5);
+    BOOST_TEST(it1.is_valid(&cb3));
+    BOOST_TEST(!it2.is_valid(&cb3));
+    BOOST_TEST(*it2.m_it == 5);
 
     it1 = cb3.begin() + 3;
     it2 = cb3.end() - 1;
     cb3.push_front(7);
-    BOOST_CHECK(it1.is_valid(&cb3));
-    BOOST_CHECK(!it2.is_valid(&cb3));
-    BOOST_CHECK(*it2.m_it == 7);
+    BOOST_TEST(it1.is_valid(&cb3));
+    BOOST_TEST(!it2.is_valid(&cb3));
+    BOOST_TEST(*it2.m_it == 7);
 
     circular_buffer<MyInteger> cb4(5);
     cb4.push_back(1);
@@ -293,51 +293,51 @@ void iterator_invalidation_test() {
     it1 = cb4.begin() + 3;
     it2 = cb4.begin();
     cb4.rinsert(cb4.begin() + 2, 6);
-    BOOST_CHECK(it1.is_valid(&cb4));
-    BOOST_CHECK(!it2.is_valid(&cb4));
-    BOOST_CHECK(*it2.m_it == 2);
+    BOOST_TEST(it1.is_valid(&cb4));
+    BOOST_TEST(!it2.is_valid(&cb4));
+    BOOST_TEST(*it2.m_it == 2);
 
     it1 = cb1.begin() + 5;
     it2 = cb1.end() - 1;
     cb1.pop_back();
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
 
     it1 = cb1.begin() + 5;
     it2 = cb1.begin();
     cb1.pop_front();
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
 
     circular_buffer<MyInteger> cb5(20, 0);
     it1 = cb5.begin() + 5;
     it2 = it3 = cb5.begin() + 15;
     cb5.erase(cb5.begin() + 10);
-    BOOST_CHECK(it1.is_valid(&cb5));
-    BOOST_CHECK(!it2.is_valid(&cb5));
-    BOOST_CHECK(!it3.is_valid(&cb5));
+    BOOST_TEST(it1.is_valid(&cb5));
+    BOOST_TEST(!it2.is_valid(&cb5));
+    BOOST_TEST(!it3.is_valid(&cb5));
 
     it1 = cb5.begin() + 1;
     it2 = it3 = cb5.begin() + 8;
     cb5.erase(cb5.begin() + 3, cb5.begin() + 7);
-    BOOST_CHECK(it1.is_valid(&cb5));
-    BOOST_CHECK(!it2.is_valid(&cb5));
-    BOOST_CHECK(!it3.is_valid(&cb5));
+    BOOST_TEST(it1.is_valid(&cb5));
+    BOOST_TEST(!it2.is_valid(&cb5));
+    BOOST_TEST(!it3.is_valid(&cb5));
 
     circular_buffer<MyInteger> cb6(20, 0);
     it4 = it1 = cb6.begin() + 5;
     it2 = cb6.begin() + 15;
     cb6.rerase(cb6.begin() + 10);
-    BOOST_CHECK(!it1.is_valid(&cb6));
-    BOOST_CHECK(!it4.is_valid(&cb6));
-    BOOST_CHECK(it2.is_valid(&cb6));
+    BOOST_TEST(!it1.is_valid(&cb6));
+    BOOST_TEST(!it4.is_valid(&cb6));
+    BOOST_TEST(it2.is_valid(&cb6));
 
     it4 = it1 = cb6.begin() + 1;
     it2 = cb6.begin() + 8;
     cb6.rerase(cb6.begin() + 3, cb6.begin() + 7);
-    BOOST_CHECK(!it1.is_valid(&cb6));
-    BOOST_CHECK(!it4.is_valid(&cb6));
-    BOOST_CHECK(it2.is_valid(&cb6));
+    BOOST_TEST(!it1.is_valid(&cb6));
+    BOOST_TEST(!it4.is_valid(&cb6));
+    BOOST_TEST(it2.is_valid(&cb6));
 
     circular_buffer<MyInteger> cb7(10, 1);
     cb7.push_back(2);
@@ -347,16 +347,16 @@ void iterator_invalidation_test() {
     it2 = cb7.begin();
     it3 = cb7.begin() + 6;
     cb7.linearize();
-    BOOST_CHECK(it1.is_valid(&cb7));
-    BOOST_CHECK(!it2.is_valid(&cb7));
-    BOOST_CHECK(!it3.is_valid(&cb7));
+    BOOST_TEST(it1.is_valid(&cb7));
+    BOOST_TEST(!it2.is_valid(&cb7));
+    BOOST_TEST(!it3.is_valid(&cb7));
     it1 = cb7.end();
     it2 = cb7.begin();
     it3 = cb7.begin() + 6;
     cb7.linearize();
-    BOOST_CHECK(it1.is_valid(&cb7));
-    BOOST_CHECK(it2.is_valid(&cb7));
-    BOOST_CHECK(it3.is_valid(&cb7));
+    BOOST_TEST(it1.is_valid(&cb7));
+    BOOST_TEST(it2.is_valid(&cb7));
+    BOOST_TEST(it3.is_valid(&cb7));
 
     cb7.push_back(5);
     cb7.push_back(6);
@@ -364,21 +364,21 @@ void iterator_invalidation_test() {
     it2 = cb7.begin();
     it3 = cb7.begin() + 6;
     cb7.set_capacity(10);
-    BOOST_CHECK(it1.is_valid(&cb7));
-    BOOST_CHECK(it2.is_valid(&cb7));
-    BOOST_CHECK(it3.is_valid(&cb7));
+    BOOST_TEST(it1.is_valid(&cb7));
+    BOOST_TEST(it2.is_valid(&cb7));
+    BOOST_TEST(it3.is_valid(&cb7));
     cb7.set_capacity(20);
-    BOOST_CHECK(it1.is_valid(&cb7));
-    BOOST_CHECK(!it2.is_valid(&cb7));
-    BOOST_CHECK(!it3.is_valid(&cb7));
+    BOOST_TEST(it1.is_valid(&cb7));
+    BOOST_TEST(!it2.is_valid(&cb7));
+    BOOST_TEST(!it3.is_valid(&cb7));
     cb7.push_back(7);
     it1 = cb7.end();
     it2 = cb7.begin();
     it3 = cb7.begin() + 6;
     cb7.set_capacity(10);
-    BOOST_CHECK(it1.is_valid(&cb7));
-    BOOST_CHECK(!it2.is_valid(&cb7));
-    BOOST_CHECK(!it3.is_valid(&cb7));
+    BOOST_TEST(it1.is_valid(&cb7));
+    BOOST_TEST(!it2.is_valid(&cb7));
+    BOOST_TEST(!it3.is_valid(&cb7));
 
     cb7.push_back(8);
     cb7.push_back(9);
@@ -386,21 +386,21 @@ void iterator_invalidation_test() {
     it2 = cb7.begin();
     it3 = cb7.begin() + 6;
     cb7.rset_capacity(10);
-    BOOST_CHECK(it1.is_valid(&cb7));
-    BOOST_CHECK(it2.is_valid(&cb7));
-    BOOST_CHECK(it3.is_valid(&cb7));
+    BOOST_TEST(it1.is_valid(&cb7));
+    BOOST_TEST(it2.is_valid(&cb7));
+    BOOST_TEST(it3.is_valid(&cb7));
     cb7.rset_capacity(20);
-    BOOST_CHECK(it1.is_valid(&cb7));
-    BOOST_CHECK(!it2.is_valid(&cb7));
-    BOOST_CHECK(!it3.is_valid(&cb7));
+    BOOST_TEST(it1.is_valid(&cb7));
+    BOOST_TEST(!it2.is_valid(&cb7));
+    BOOST_TEST(!it3.is_valid(&cb7));
     cb7.push_back(10);
     it1 = cb7.end();
     it2 = cb7.begin();
     it3 = cb7.begin() + 6;
     cb7.rset_capacity(10);
-    BOOST_CHECK(it1.is_valid(&cb7));
-    BOOST_CHECK(!it2.is_valid(&cb7));
-    BOOST_CHECK(!it3.is_valid(&cb7));
+    BOOST_TEST(it1.is_valid(&cb7));
+    BOOST_TEST(!it2.is_valid(&cb7));
+    BOOST_TEST(!it3.is_valid(&cb7));
 
     circular_buffer<MyInteger> cb8(10, 1);
     cb8.push_back(2);
@@ -409,23 +409,23 @@ void iterator_invalidation_test() {
     it2 = cb8.begin();
     it3 = cb8.begin() + 6;
     cb8.resize(10);
-    BOOST_CHECK(it1.is_valid(&cb8));
-    BOOST_CHECK(it2.is_valid(&cb8));
-    BOOST_CHECK(it3.is_valid(&cb8));
+    BOOST_TEST(it1.is_valid(&cb8));
+    BOOST_TEST(it2.is_valid(&cb8));
+    BOOST_TEST(it3.is_valid(&cb8));
     cb8.resize(20);
-    BOOST_CHECK(it1.is_valid(&cb8));
-    BOOST_CHECK(!it2.is_valid(&cb8));
-    BOOST_CHECK(!it3.is_valid(&cb8));
+    BOOST_TEST(it1.is_valid(&cb8));
+    BOOST_TEST(!it2.is_valid(&cb8));
+    BOOST_TEST(!it3.is_valid(&cb8));
     cb8.push_back(4);
     it1 = cb8.end();
     it2 = cb8.begin();
     it3 = cb8.begin() + 6;
     it4 = cb8.begin() + 12;
     cb8.resize(10);
-    BOOST_CHECK(it1.is_valid(&cb8));
-    BOOST_CHECK(it2.is_valid(&cb8));
-    BOOST_CHECK(it3.is_valid(&cb8));
-    BOOST_CHECK(!it4.is_valid(&cb8));
+    BOOST_TEST(it1.is_valid(&cb8));
+    BOOST_TEST(it2.is_valid(&cb8));
+    BOOST_TEST(it3.is_valid(&cb8));
+    BOOST_TEST(!it4.is_valid(&cb8));
 
     cb8.set_capacity(10);
     cb8.push_back(5);
@@ -434,23 +434,23 @@ void iterator_invalidation_test() {
     it2 = cb8.begin();
     it3 = cb8.begin() + 6;
     cb8.rresize(10);
-    BOOST_CHECK(it1.is_valid(&cb8));
-    BOOST_CHECK(it2.is_valid(&cb8));
-    BOOST_CHECK(it3.is_valid(&cb8));
+    BOOST_TEST(it1.is_valid(&cb8));
+    BOOST_TEST(it2.is_valid(&cb8));
+    BOOST_TEST(it3.is_valid(&cb8));
     cb8.rresize(20);
-    BOOST_CHECK(it1.is_valid(&cb8));
-    BOOST_CHECK(!it2.is_valid(&cb8));
-    BOOST_CHECK(!it3.is_valid(&cb8));
+    BOOST_TEST(it1.is_valid(&cb8));
+    BOOST_TEST(!it2.is_valid(&cb8));
+    BOOST_TEST(!it3.is_valid(&cb8));
     cb8.push_back(7);
     it1 = cb8.end();
     it2 = cb8.begin();
     it3 = cb8.begin() + 6;
     it4 = cb8.begin() + 12;
     cb8.rresize(10);
-    BOOST_CHECK(it1.is_valid(&cb8));
-    BOOST_CHECK(!it2.is_valid(&cb8));
-    BOOST_CHECK(!it3.is_valid(&cb8));
-    BOOST_CHECK(it4.is_valid(&cb8));
+    BOOST_TEST(it1.is_valid(&cb8));
+    BOOST_TEST(!it2.is_valid(&cb8));
+    BOOST_TEST(!it3.is_valid(&cb8));
+    BOOST_TEST(it4.is_valid(&cb8));
 
     circular_buffer<MyInteger> cb9(15, 1);
     it1 = cb9.end();
@@ -458,10 +458,10 @@ void iterator_invalidation_test() {
     it3 = cb9.begin() + 6;
     it4 = cb9.begin() + 12;
     cb9 = cb8;
-    BOOST_CHECK(it1.is_valid(&cb9));
-    BOOST_CHECK(!it2.is_valid(&cb9));
-    BOOST_CHECK(!it3.is_valid(&cb9));
-    BOOST_CHECK(!it4.is_valid(&cb9));
+    BOOST_TEST(it1.is_valid(&cb9));
+    BOOST_TEST(!it2.is_valid(&cb9));
+    BOOST_TEST(!it3.is_valid(&cb9));
+    BOOST_TEST(!it4.is_valid(&cb9));
 
     circular_buffer<MyInteger> cb10(10, 1);
     it1 = cb10.end();
@@ -469,10 +469,10 @@ void iterator_invalidation_test() {
     it3 = cb10.begin() + 3;
     it4 = cb10.begin() + 7;
     cb10.assign(5, 2);
-    BOOST_CHECK(it1.is_valid(&cb10));
-    BOOST_CHECK(!it2.is_valid(&cb10));
-    BOOST_CHECK(!it3.is_valid(&cb10));
-    BOOST_CHECK(!it4.is_valid(&cb10));
+    BOOST_TEST(it1.is_valid(&cb10));
+    BOOST_TEST(!it2.is_valid(&cb10));
+    BOOST_TEST(!it3.is_valid(&cb10));
+    BOOST_TEST(!it4.is_valid(&cb10));
 
     circular_buffer<MyInteger> cb11(10, 1);
     it1 = cb11.end();
@@ -480,10 +480,10 @@ void iterator_invalidation_test() {
     it3 = cb11.begin() + 3;
     it4 = cb11.begin() + 7;
     cb11.assign(15, 5, 2);
-    BOOST_CHECK(it1.is_valid(&cb11));
-    BOOST_CHECK(!it2.is_valid(&cb11));
-    BOOST_CHECK(!it3.is_valid(&cb11));
-    BOOST_CHECK(!it4.is_valid(&cb11));
+    BOOST_TEST(it1.is_valid(&cb11));
+    BOOST_TEST(!it2.is_valid(&cb11));
+    BOOST_TEST(!it3.is_valid(&cb11));
+    BOOST_TEST(!it4.is_valid(&cb11));
 
     circular_buffer<MyInteger> cb12(10, 1);
     it1 = cb12.end();
@@ -491,10 +491,10 @@ void iterator_invalidation_test() {
     it3 = cb12.begin() + 3;
     it4 = cb12.begin() + 7;
     cb12.assign(cb11.begin(), cb11.end());
-    BOOST_CHECK(it1.is_valid(&cb12));
-    BOOST_CHECK(!it2.is_valid(&cb12));
-    BOOST_CHECK(!it3.is_valid(&cb12));
-    BOOST_CHECK(!it4.is_valid(&cb12));
+    BOOST_TEST(it1.is_valid(&cb12));
+    BOOST_TEST(!it2.is_valid(&cb12));
+    BOOST_TEST(!it3.is_valid(&cb12));
+    BOOST_TEST(!it4.is_valid(&cb12));
 
     circular_buffer<MyInteger> cb13(10, 1);
     it1 = cb13.end();
@@ -502,10 +502,10 @@ void iterator_invalidation_test() {
     it3 = cb13.begin() + 3;
     it4 = cb13.begin() + 7;
     cb13.assign(15, cb11.begin(), cb11.end());
-    BOOST_CHECK(it1.is_valid(&cb13));
-    BOOST_CHECK(!it2.is_valid(&cb13));
-    BOOST_CHECK(!it3.is_valid(&cb13));
-    BOOST_CHECK(!it4.is_valid(&cb13));
+    BOOST_TEST(it1.is_valid(&cb13));
+    BOOST_TEST(!it2.is_valid(&cb13));
+    BOOST_TEST(!it3.is_valid(&cb13));
+    BOOST_TEST(!it4.is_valid(&cb13));
 
     circular_buffer<MyInteger> cb14(10);
     cb14.push_back(1);
@@ -520,10 +520,10 @@ void iterator_invalidation_test() {
     it3 = cb14.begin() + 1;
     it4 = cb14.begin() + 5;
     cb14.rotate(it2);
-    BOOST_CHECK(it1.is_valid(&cb14));
-    BOOST_CHECK(it2.is_valid(&cb14));
-    BOOST_CHECK(!it3.is_valid(&cb14));
-    BOOST_CHECK(it4.is_valid(&cb14));
+    BOOST_TEST(it1.is_valid(&cb14));
+    BOOST_TEST(it2.is_valid(&cb14));
+    BOOST_TEST(!it3.is_valid(&cb14));
+    BOOST_TEST(it4.is_valid(&cb14));
 
     circular_buffer<MyInteger> cb15(7);
     cb15.push_back(1);
@@ -540,10 +540,10 @@ void iterator_invalidation_test() {
     it3 = cb15.begin() + 1;
     it4 = cb15.begin() + 5;
     cb15.rotate(it3);
-    BOOST_CHECK(it1.is_valid(&cb15));
-    BOOST_CHECK(it2.is_valid(&cb15));
-    BOOST_CHECK(it3.is_valid(&cb15));
-    BOOST_CHECK(it4.is_valid(&cb15));
+    BOOST_TEST(it1.is_valid(&cb15));
+    BOOST_TEST(it2.is_valid(&cb15));
+    BOOST_TEST(it3.is_valid(&cb15));
+    BOOST_TEST(it4.is_valid(&cb15));
 
     circular_buffer<MyInteger> cb16(10);
     cb16.push_back(1);
@@ -558,10 +558,10 @@ void iterator_invalidation_test() {
     it3 = cb16.begin();
     it4 = cb16.begin() + 5;
     cb16.rotate(it4);
-    BOOST_CHECK(it1.is_valid(&cb16));
-    BOOST_CHECK(!it2.is_valid(&cb16));
-    BOOST_CHECK(it3.is_valid(&cb16));
-    BOOST_CHECK(!it4.is_valid(&cb16));
+    BOOST_TEST(it1.is_valid(&cb16));
+    BOOST_TEST(!it2.is_valid(&cb16));
+    BOOST_TEST(it3.is_valid(&cb16));
+    BOOST_TEST(!it4.is_valid(&cb16));
 
 #endif // #if BOOST_CB_ENABLE_DEBUG
 }
@@ -573,168 +573,168 @@ void exception_safety_test() {
 
     circular_buffer<MyInteger> cb1(3, 5);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb1.set_capacity(5), std::exception);
-    BOOST_CHECK(cb1.capacity() == 3);
+    BOOST_TEST_THROWS(cb1.set_capacity(5), std::exception);
+    BOOST_TEST(cb1.capacity() == 3);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb1.rset_capacity(5), std::exception);
-    BOOST_CHECK(cb1.capacity() == 3);
+    BOOST_TEST_THROWS(cb1.rset_capacity(5), std::exception);
+    BOOST_TEST(cb1.capacity() == 3);
     generic_test(cb1);
 
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb2(5, 10), std::exception);
+    BOOST_TEST_THROWS(circular_buffer<MyInteger> cb2(5, 10), std::exception);
 
     circular_buffer<MyInteger> cb3(5, 10);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb4(cb3), std::exception);
+    BOOST_TEST_THROWS(circular_buffer<MyInteger> cb4(cb3), std::exception);
 
     vector<MyInteger> v(5, MyInteger(10));
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb5(8, v.begin(), v.end()), std::exception);
+    BOOST_TEST_THROWS(circular_buffer<MyInteger> cb5(8, v.begin(), v.end()), std::exception);
 
     circular_buffer<MyInteger> cb6(5, 10);
     circular_buffer<MyInteger> cb7(8, 3);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb7 = cb6, std::exception);
-    BOOST_CHECK(cb7.size() == 8);
-    BOOST_CHECK(cb7.capacity() == 8);
-    BOOST_CHECK(cb7[0] == 3);
-    BOOST_CHECK(cb7[7] == 3);
+    BOOST_TEST_THROWS(cb7 = cb6, std::exception);
+    BOOST_TEST(cb7.size() == 8);
+    BOOST_TEST(cb7.capacity() == 8);
+    BOOST_TEST(cb7[0] == 3);
+    BOOST_TEST(cb7[7] == 3);
     generic_test(cb7);
 
     circular_buffer<MyInteger> cb8(5, 10);
     MyInteger::set_exception_trigger(2);
-    BOOST_CHECK_THROW(cb8.push_front(1), std::exception);
+    BOOST_TEST_THROWS(cb8.push_front(1), std::exception);
 
     circular_buffer<MyInteger> cb9(5);
     cb9.push_back(1);
     cb9.push_back(2);
     cb9.push_back(3);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb9.insert(cb9.begin() + 1, 4), std::exception);
+    BOOST_TEST_THROWS(cb9.insert(cb9.begin() + 1, 4), std::exception);
 
     circular_buffer<MyInteger> cb10(5);
     cb10.push_back(1);
     cb10.push_back(2);
     cb10.push_back(3);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb10.rinsert(cb10.begin() + 1, 4), std::exception);
+    BOOST_TEST_THROWS(cb10.rinsert(cb10.begin() + 1, 4), std::exception);
 
     circular_buffer<MyInteger> cb11(5);
     cb11.push_back(1);
     cb11.push_back(2);
     MyInteger::set_exception_trigger(2);
-    BOOST_CHECK_THROW(cb11.rinsert(cb11.begin(), 1), std::exception);
+    BOOST_TEST_THROWS(cb11.rinsert(cb11.begin(), 1), std::exception);
 
     circular_buffer<MyInteger> cb12(5, 1);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb12.assign(4, 2), std::exception);
+    BOOST_TEST_THROWS(cb12.assign(4, 2), std::exception);
 
     circular_buffer<MyInteger> cb13(5, 1);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb13.assign(6, 2), std::exception);
+    BOOST_TEST_THROWS(cb13.assign(6, 2), std::exception);
 
     circular_buffer<MyInteger> cb14(5);
     cb14.push_back(1);
     cb14.push_back(2);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb14.insert(cb14.begin(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb14.insert(cb14.begin(), 10, 3), std::exception);
 
     circular_buffer<MyInteger> cb15(5);
     cb15.push_back(1);
     cb15.push_back(2);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb15.insert(cb15.end(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb15.insert(cb15.end(), 10, 3), std::exception);
 
     circular_buffer<MyInteger> cb16(5);
     cb16.push_back(1);
     cb16.push_back(2);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb16.rinsert(cb16.begin(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb16.rinsert(cb16.begin(), 10, 3), std::exception);
 
     circular_buffer<MyInteger> cb17(5);
     cb17.push_back(1);
     cb17.push_back(2);
     MyInteger::set_exception_trigger(3);
-    BOOST_CHECK_THROW(cb17.rinsert(cb17.end(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb17.rinsert(cb17.end(), 10, 3), std::exception);
 
     circular_buffer<MyInteger> cb18(5, 0);
     cb18.push_back(1);
     cb18.push_back(2);
     cb18.pop_front();
     MyInteger::set_exception_trigger(4);
-    BOOST_CHECK_THROW(cb18.linearize(), std::exception);
+    BOOST_TEST_THROWS(cb18.linearize(), std::exception);
 
     circular_buffer<MyInteger> cb19(5, 0);
     cb19.push_back(1);
     cb19.push_back(2);
     MyInteger::set_exception_trigger(5);
-    BOOST_CHECK_THROW(cb19.linearize(), std::exception);
+    BOOST_TEST_THROWS(cb19.linearize(), std::exception);
 
     circular_buffer<MyInteger> cb20(5, 0);
     cb20.push_back(1);
     cb20.push_back(2);
     MyInteger::set_exception_trigger(6);
-    BOOST_CHECK_THROW(cb20.linearize(), std::exception);
+    BOOST_TEST_THROWS(cb20.linearize(), std::exception);
 
     circular_buffer<MyInteger> cb21(5);
     cb21.push_back(1);
     cb21.push_back(2);
     cb21.push_back(3);
     MyInteger::set_exception_trigger(2);
-    BOOST_CHECK_THROW(cb21.insert(cb21.begin() + 1, 4), std::exception);
+    BOOST_TEST_THROWS(cb21.insert(cb21.begin() + 1, 4), std::exception);
 
     circular_buffer<MyInteger> cb22(5);
     cb22.push_back(1);
     cb22.push_back(2);
     cb22.push_back(3);
     MyInteger::set_exception_trigger(2);
-    BOOST_CHECK_THROW(cb22.insert(cb22.end(), 4), std::exception);
+    BOOST_TEST_THROWS(cb22.insert(cb22.end(), 4), std::exception);
 
     circular_buffer<MyInteger> cb23(5, 0);
     MyInteger::set_exception_trigger(2);
-    BOOST_CHECK_THROW(cb23.insert(cb23.begin() + 1, 4), std::exception);
+    BOOST_TEST_THROWS(cb23.insert(cb23.begin() + 1, 4), std::exception);
 
     circular_buffer<MyInteger> cb24(5);
     cb24.push_back(1);
     cb24.push_back(2);
     cb24.push_back(3);
     MyInteger::set_exception_trigger(2);
-    BOOST_CHECK_THROW(cb24.rinsert(cb24.begin() + 1, 4), std::exception);
+    BOOST_TEST_THROWS(cb24.rinsert(cb24.begin() + 1, 4), std::exception);
 
     circular_buffer<MyInteger> cb25(5, 0);
     MyInteger::set_exception_trigger(2);
-    BOOST_CHECK_THROW(cb25.rinsert(cb25.begin() + 3, 4), std::exception);
+    BOOST_TEST_THROWS(cb25.rinsert(cb25.begin() + 3, 4), std::exception);
 
     circular_buffer<MyInteger> cb26(5);
     cb26.push_back(1);
     cb26.push_back(2);
     MyInteger::set_exception_trigger(5);
-    BOOST_CHECK_THROW(cb26.insert(cb26.begin(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb26.insert(cb26.begin(), 10, 3), std::exception);
 
     circular_buffer<MyInteger> cb27(5);
     cb27.push_back(1);
     cb27.push_back(2);
     MyInteger::set_exception_trigger(5);
-    BOOST_CHECK_THROW(cb27.insert(cb27.end(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb27.insert(cb27.end(), 10, 3), std::exception);
 
     circular_buffer<MyInteger> cb28(5);
     cb28.push_back(1);
     cb28.push_back(2);
     MyInteger::set_exception_trigger(5);
-    BOOST_CHECK_THROW(cb28.rinsert(cb28.begin(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb28.rinsert(cb28.begin(), 10, 3), std::exception);
 
     circular_buffer<MyInteger> cb29(5);
     cb29.push_back(1);
     cb29.push_back(2);
     MyInteger::set_exception_trigger(5);
-    BOOST_CHECK_THROW(cb29.rinsert(cb29.end(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb29.rinsert(cb29.end(), 10, 3), std::exception);
 
     circular_buffer<MyInteger> cb30(10);
     cb30.push_back(1);
     cb30.push_back(2);
     cb30.push_back(3);
     MyInteger::set_exception_trigger(2);
-    BOOST_CHECK_THROW(cb30.rinsert(cb30.begin(), 10, 3), std::exception);
+    BOOST_TEST_THROWS(cb30.rinsert(cb30.begin(), 10, 3), std::exception);
 
 #endif // #if !defined(BOOST_NO_EXCEPTIONS)
 }
@@ -752,84 +752,84 @@ void move_container_values_resetting_impl() {
     cb1.push_back();
 
     cb1.push_back(boost::move(var));
-    BOOST_CHECK(!cb1.back().is_moved());
-    BOOST_CHECK(var.is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(!cb1.back().is_moved());
+    BOOST_TEST(var.is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
 
     cb1.push_front(boost::move(var));
-    BOOST_CHECK(!cb1.front().is_moved());
-    BOOST_CHECK(var.is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(!cb1.front().is_moved());
+    BOOST_TEST(var.is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
 
     cb1.push_back();
-    BOOST_CHECK(!cb1.back().is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(!cb1.back().is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
 
     cb1.push_front();
-    BOOST_CHECK(!cb1.front().is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(!cb1.front().is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
 
 
     cb1.insert(cb1.begin());
     // If the circular_buffer is full and the pos points to begin(), 
     // then the item will not be inserted.
-    BOOST_CHECK(cb1.front().is_moved()); 
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(cb1.front().is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
 
     cb1.insert(cb1.begin(), boost::move(var));
     // If the circular_buffer is full and the pos points to begin(), 
     // then the item will not be inserted.
-    BOOST_CHECK(cb1.front().is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(cb1.front().is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
 
     cb1.rinsert(cb1.begin());
-    BOOST_CHECK(!cb1.back().is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(!cb1.back().is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
 
     var.reinit();
     cb1.rinsert(cb1.begin(), boost::move(var));
-    BOOST_CHECK(!cb1.back().is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(!cb1.back().is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
     
     cb1.rinsert(cb1.end());
-    BOOST_CHECK(cb1.back().is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(cb1.back().is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
 
     var.reinit();
     cb1.rinsert(cb1.end(), boost::move(var));
-    BOOST_CHECK(cb1.back().is_moved());
-    BOOST_CHECK(cb1.size() == 1);
+    BOOST_TEST(cb1.back().is_moved());
+    BOOST_TEST(cb1.size() == 1);
     var = boost::move(cb1.back());
-    BOOST_CHECK(cb1.back().is_moved());
+    BOOST_TEST(cb1.back().is_moved());
     cb1.push_back();
-    BOOST_CHECK(!cb1[0].is_moved());
+    BOOST_TEST(!cb1[0].is_moved());
 
     const int val = cb1[0].value();
     cb1.linearize();
-    BOOST_CHECK(!cb1[0].is_moved());
-    BOOST_CHECK(cb1[0].value() == val);
+    BOOST_TEST(!cb1[0].is_moved());
+    BOOST_TEST(cb1[0].value() == val);
 
     cb1.rotate(cb1.begin());
-    BOOST_CHECK(!cb1[0].is_moved());
-    BOOST_CHECK(cb1[0].value() == val);
+    BOOST_TEST(!cb1[0].is_moved());
+    BOOST_TEST(cb1[0].value() == val);
 }
 
 void move_container_values_resetting_except() {
@@ -841,25 +841,22 @@ void move_container_values_resetting_noexcept() {
 }
 
 // test main
-test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
-
-    test_suite* tests = BOOST_TEST_SUITE("Unit tests for the circular_buffer.");
-    add_common_tests(tests);
-
-    tests->add(BOOST_TEST_CASE(&iterator_constructor_and_assign_test));
-    tests->add(BOOST_TEST_CASE(&iterator_reference_test));
-    tests->add(BOOST_TEST_CASE(&iterator_difference_test));
-    tests->add(BOOST_TEST_CASE(&iterator_increment_test));
-    tests->add(BOOST_TEST_CASE(&iterator_decrement_test));
-    tests->add(BOOST_TEST_CASE(&iterator_addition_test));
-    tests->add(BOOST_TEST_CASE(&iterator_subtraction_test));
-    tests->add(BOOST_TEST_CASE(&iterator_element_access_test));
-    tests->add(BOOST_TEST_CASE(&iterator_comparison_test));
-    tests->add(BOOST_TEST_CASE(&iterator_invalidation_test));
-    tests->add(BOOST_TEST_CASE(&exception_safety_test));
-    tests->add(BOOST_TEST_CASE(&move_container_values_except));
-    tests->add(BOOST_TEST_CASE(&move_container_values_resetting_except));
-    tests->add(BOOST_TEST_CASE(&move_container_values_resetting_noexcept));
-
-    return tests;
+int main()
+{
+    run_common_tests();
+    iterator_constructor_and_assign_test();
+    iterator_reference_test();
+    iterator_difference_test();
+    iterator_increment_test();
+    iterator_decrement_test();
+    iterator_addition_test();
+    iterator_subtraction_test();
+    iterator_element_access_test();
+    iterator_comparison_test();
+    iterator_invalidation_test();
+    exception_safety_test();
+    move_container_values_except();
+    move_container_values_resetting_except();
+    move_container_values_resetting_noexcept();
+    return boost::report_errors();
 }

test/bounded_buffer_comparison.cpp

@@ -11,8 +11,8 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/thread.hpp>
+#include <boost/timer/timer.hpp>
 #include <boost/call_traits.hpp>
-#include <boost/progress.hpp>
 #include <boost/bind.hpp>
 #include <deque>
 #include <list>
@@ -229,7 +229,7 @@ template<class Buffer>
 void fifo_test(Buffer* buffer) {
 
     // Start of measurement
-    boost::progress_timer progress;
+    boost::timer::auto_cpu_timer progress;
 
     // Initialize the buffer with some values before launching producer and consumer threads.
     for (unsigned long i = QUEUE_SIZE / 2L; i > 0; --i) {

test/constant_erase_test.cpp

@@ -25,35 +25,35 @@ void erase_begin_test() {
 
     cb1.erase_begin(2);
 
-    BOOST_CHECK(cb1.size() == 3);
-    BOOST_CHECK(cb1[0] == 4);
-    BOOST_CHECK(cb1[1] == 5);
-    BOOST_CHECK(cb1[2] == 6);
+    BOOST_TEST(cb1.size() == 3);
+    BOOST_TEST(cb1[0] == 4);
+    BOOST_TEST(cb1[1] == 5);
+    BOOST_TEST(cb1[2] == 6);
 
     cb1.erase_begin(3);
-    BOOST_CHECK(cb1.empty());
-    BOOST_CHECK(*p == 2);
-    BOOST_CHECK(*(p + 1) == 3);
-    BOOST_CHECK(*(p + 2) == 4);
+    BOOST_TEST(cb1.empty());
+    BOOST_TEST(*p == 2);
+    BOOST_TEST(*(p + 1) == 3);
+    BOOST_TEST(*(p + 2) == 4);
 
     cb1.push_back(10);
     cb1.push_back(11);
     cb1.push_back(12);
 
-    BOOST_CHECK(cb1.size() == 3);
-    BOOST_CHECK(cb1[0] == 10);
-    BOOST_CHECK(cb1[1] == 11);
-    BOOST_CHECK(cb1[2] == 12);
+    BOOST_TEST(cb1.size() == 3);
+    BOOST_TEST(cb1[0] == 10);
+    BOOST_TEST(cb1[1] == 11);
+    BOOST_TEST(cb1[2] == 12);
 
     circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
 
-    BOOST_CHECK(cb2.size() == 5);
-    BOOST_CHECK(InstanceCounter::count() == 5);
+    BOOST_TEST(cb2.size() == 5);
+    BOOST_TEST(InstanceCounter::count() == 5);
 
     cb2.erase_begin(2);
 
-    BOOST_CHECK(cb2.size() == 3);
-    BOOST_CHECK(InstanceCounter::count() == 3);
+    BOOST_TEST(cb2.size() == 3);
+    BOOST_TEST(InstanceCounter::count() == 3);
 
     circular_buffer<MyInteger> cb3(5);
     cb3.push_back(1);
@@ -64,10 +64,10 @@ void erase_begin_test() {
     cb3.push_back(6);
     cb3.erase_begin(2);
 
-    BOOST_CHECK(cb3.size() == 3);
-    BOOST_CHECK(cb3[0] == 4);
-    BOOST_CHECK(cb3[1] == 5);
-    BOOST_CHECK(cb3[2] == 6);
+    BOOST_TEST(cb3.size() == 3);
+    BOOST_TEST(cb3[0] == 4);
+    BOOST_TEST(cb3[1] == 5);
+    BOOST_TEST(cb3[2] == 6);
 }
 
 void erase_end_test() {
@@ -84,35 +84,35 @@ void erase_end_test() {
 
     cb1.erase_end(2);
 
-    BOOST_CHECK(cb1.size() == 3);
-    BOOST_CHECK(cb1[0] == 2);
-    BOOST_CHECK(cb1[1] == 3);
-    BOOST_CHECK(cb1[2] ==4);
+    BOOST_TEST(cb1.size() == 3);
+    BOOST_TEST(cb1[0] == 2);
+    BOOST_TEST(cb1[1] == 3);
+    BOOST_TEST(cb1[2] ==4);
 
     cb1.erase_end(3);
-    BOOST_CHECK(cb1.empty());
-    BOOST_CHECK(*p == 5);
-    BOOST_CHECK(*(p - 1) == 4);
-    BOOST_CHECK(*(p - 2) == 3);
+    BOOST_TEST(cb1.empty());
+    BOOST_TEST(*p == 5);
+    BOOST_TEST(*(p - 1) == 4);
+    BOOST_TEST(*(p - 2) == 3);
 
     cb1.push_back(10);
     cb1.push_back(11);
     cb1.push_back(12);
 
-    BOOST_CHECK(cb1.size() == 3);
-    BOOST_CHECK(cb1[0] == 10);
-    BOOST_CHECK(cb1[1] == 11);
-    BOOST_CHECK(cb1[2] == 12);
+    BOOST_TEST(cb1.size() == 3);
+    BOOST_TEST(cb1[0] == 10);
+    BOOST_TEST(cb1[1] == 11);
+    BOOST_TEST(cb1[2] == 12);
 
     circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
 
-    BOOST_CHECK(cb2.size() == 5);
-    BOOST_CHECK(InstanceCounter::count() == 5);
+    BOOST_TEST(cb2.size() == 5);
+    BOOST_TEST(InstanceCounter::count() == 5);
 
     cb2.erase_end(2);
 
-    BOOST_CHECK(cb2.size() == 3);
-    BOOST_CHECK(InstanceCounter::count() == 3);
+    BOOST_TEST(cb2.size() == 3);
+    BOOST_TEST(InstanceCounter::count() == 3);
 
     circular_buffer<MyInteger> cb3(5);
     cb3.push_back(1);
@@ -123,10 +123,10 @@ void erase_end_test() {
     cb3.push_back(6);
     cb3.erase_end(2);
 
-    BOOST_CHECK(cb3.size() == 3);
-    BOOST_CHECK(cb3[0] == 2);
-    BOOST_CHECK(cb3[1] == 3);
-    BOOST_CHECK(cb3[2] == 4);
+    BOOST_TEST(cb3.size() == 3);
+    BOOST_TEST(cb3[0] == 2);
+    BOOST_TEST(cb3[1] == 3);
+    BOOST_TEST(cb3[2] == 4);
 }
 
 void clear_test() {
@@ -143,22 +143,22 @@ void clear_test() {
 
     cb1.clear();
 
-    BOOST_CHECK(cb1.empty());
-    BOOST_CHECK(*p == 2);
-    BOOST_CHECK(*(p + 1) == 3);
-    BOOST_CHECK(*(p + 2) == 4);
-    BOOST_CHECK(*(p + 3) == 5);
-    BOOST_CHECK(*(p - 1) == 6);
+    BOOST_TEST(cb1.empty());
+    BOOST_TEST(*p == 2);
+    BOOST_TEST(*(p + 1) == 3);
+    BOOST_TEST(*(p + 2) == 4);
+    BOOST_TEST(*(p + 3) == 5);
+    BOOST_TEST(*(p - 1) == 6);
 
     circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
 
-    BOOST_CHECK(cb2.size() == 5);
-    BOOST_CHECK(InstanceCounter::count() == 5);
+    BOOST_TEST(cb2.size() == 5);
+    BOOST_TEST(InstanceCounter::count() == 5);
 
     cb2.clear();
 
-    BOOST_CHECK(cb2.empty());
-    BOOST_CHECK(InstanceCounter::count() == 0);
+    BOOST_TEST(cb2.empty());
+    BOOST_TEST(InstanceCounter::count() == 0);
 
     circular_buffer<MyInteger> cb3(5);
     cb3.push_back(1);
@@ -169,17 +169,14 @@ void clear_test() {
     cb3.push_back(6);
     cb3.clear();
 
-    BOOST_CHECK(cb3.empty());
+    BOOST_TEST(cb3.empty());
 }
 
 // test main
-test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
-
-    test_suite* tests = BOOST_TEST_SUITE("Unit tests for erase_begin/end and clear methods of the circular_buffer.");
-
-    tests->add(BOOST_TEST_CASE(&erase_begin_test));
-    tests->add(BOOST_TEST_CASE(&erase_end_test));
-    tests->add(BOOST_TEST_CASE(&clear_test));
-
-    return tests;
+int main()
+{
+    erase_begin_test();
+    erase_end_test();
+    clear_test();
+    return boost::report_errors();
 }

test/soft_iterator_invalidation.cpp

@@ -22,11 +22,11 @@ void validity_example_test() {
 
     circular_buffer<int>::iterator it = cb.begin();
 
-    BOOST_CHECK(*it == 1);
+    BOOST_TEST(*it == 1);
 
     cb.push_back(4);
 
-    BOOST_CHECK(*it == 4);
+    BOOST_TEST(*it == 4);
 }
 
 void validity_insert_test() {
@@ -46,13 +46,13 @@ void validity_insert_test() {
 
     // memory placement: { 1, 4, 2, 3 }
     // circular buffer:  { 1, 4, 2, 3 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 2);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 4);
-    BOOST_CHECK(cb[2] == 2);
-    BOOST_CHECK(cb[3] == 3);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 2);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 4);
+    BOOST_TEST(cb[2] == 2);
+    BOOST_TEST(cb[3] == 3);
 
     // it4 -> 3
     circular_buffer<int>::iterator it4 = it1 + 3;
@@ -61,14 +61,14 @@ void validity_insert_test() {
 
     // memory placement: { 3, 5, 4, 2 }
     // circular buffer:  { 5, 4, 2, 3 }
-    BOOST_CHECK(*it1 == 3);
-    BOOST_CHECK(*it2 == 5);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(*it4 == 2);
-    BOOST_CHECK(cb[0] == 5);
-    BOOST_CHECK(cb[1] == 4);
-    BOOST_CHECK(cb[2] == 2);
-    BOOST_CHECK(cb[3] == 3);
+    BOOST_TEST(*it1 == 3);
+    BOOST_TEST(*it2 == 5);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(*it4 == 2);
+    BOOST_TEST(cb[0] == 5);
+    BOOST_TEST(cb[1] == 4);
+    BOOST_TEST(cb[2] == 2);
+    BOOST_TEST(cb[3] == 3);
 }
 
 void validity_insert_n_test() {
@@ -89,14 +89,14 @@ void validity_insert_n_test() {
 
     // memory placement: { 1, 4, 4, 2, 3 }
     // circular buffer:  { 1, 4, 4, 2, 3 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 4);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 2);
-    BOOST_CHECK(cb[4] == 3);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 4);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 2);
+    BOOST_TEST(cb[4] == 3);
 
     // it4 -> 2, it5 -> 3
     circular_buffer<int>::iterator it4 = it1 + 3;
@@ -106,16 +106,16 @@ void validity_insert_n_test() {
 
     // memory placement: { 3, 5, 4, 4, 2 } - 5 inserted only once
     // circular buffer:  { 5, 4, 4, 2, 3 }
-    BOOST_CHECK(*it1 == 3);
-    BOOST_CHECK(*it2 == 5);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(*it4 == 4);
-    BOOST_CHECK(*it5 == 2);
-    BOOST_CHECK(cb[0] == 5);
-    BOOST_CHECK(cb[1] == 4);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 2);
-    BOOST_CHECK(cb[4] == 3);
+    BOOST_TEST(*it1 == 3);
+    BOOST_TEST(*it2 == 5);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(*it4 == 4);
+    BOOST_TEST(*it5 == 2);
+    BOOST_TEST(cb[0] == 5);
+    BOOST_TEST(cb[1] == 4);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 2);
+    BOOST_TEST(cb[4] == 3);
 }
 
 void validity_insert_range_test() {
@@ -145,14 +145,14 @@ void validity_insert_range_test() {
 
     // memory placement: { 1, 4, 5, 2, 3 }
     // circular buffer:  { 1, 4, 5, 2, 3 }
-    BOOST_CHECK(*it11 == 1);
-    BOOST_CHECK(*it12 == 4);
-    BOOST_CHECK(*it13 == 5);
-    BOOST_CHECK(cb1[0] == 1);
-    BOOST_CHECK(cb1[1] == 4);
-    BOOST_CHECK(cb1[2] == 5);
-    BOOST_CHECK(cb1[3] == 2);
-    BOOST_CHECK(cb1[4] == 3);
+    BOOST_TEST(*it11 == 1);
+    BOOST_TEST(*it12 == 4);
+    BOOST_TEST(*it13 == 5);
+    BOOST_TEST(cb1[0] == 1);
+    BOOST_TEST(cb1[1] == 4);
+    BOOST_TEST(cb1[2] == 5);
+    BOOST_TEST(cb1[3] == 2);
+    BOOST_TEST(cb1[4] == 3);
 
     // it14 -> 2, it15 -> 3
     circular_buffer<int>::iterator it14 = it11 + 3;
@@ -162,16 +162,16 @@ void validity_insert_range_test() {
 
     // memory placement: { 3, 7, 4, 5, 2 } - 7 inserted only
     // circular buffer:  { 7, 4, 5, 2, 3 }
-    BOOST_CHECK(*it11 == 3);
-    BOOST_CHECK(*it12 == 7);
-    BOOST_CHECK(*it13 == 4);
-    BOOST_CHECK(*it14 == 5);
-    BOOST_CHECK(*it15 == 2);
-    BOOST_CHECK(cb1[0] == 7);
-    BOOST_CHECK(cb1[1] == 4);
-    BOOST_CHECK(cb1[2] == 5);
-    BOOST_CHECK(cb1[3] == 2);
-    BOOST_CHECK(cb1[4] == 3);
+    BOOST_TEST(*it11 == 3);
+    BOOST_TEST(*it12 == 7);
+    BOOST_TEST(*it13 == 4);
+    BOOST_TEST(*it14 == 5);
+    BOOST_TEST(*it15 == 2);
+    BOOST_TEST(cb1[0] == 7);
+    BOOST_TEST(cb1[1] == 4);
+    BOOST_TEST(cb1[2] == 5);
+    BOOST_TEST(cb1[3] == 2);
+    BOOST_TEST(cb1[4] == 3);
 
     // memory placement: { 1, 2, 3 }
     // circular buffer:  { 1, 2, 3 }
@@ -189,14 +189,14 @@ void validity_insert_range_test() {
 
     // memory placement: { 1, 4, 5, 2, 3 }
     // circular buffer:  { 1, 4, 5, 2, 3 }
-    BOOST_CHECK(*it21 == 1);
-    BOOST_CHECK(*it22 == 4);
-    BOOST_CHECK(*it23 == 5);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2[1] == 4);
-    BOOST_CHECK(cb2[2] == 5);
-    BOOST_CHECK(cb2[3] == 2);
-    BOOST_CHECK(cb2[4] == 3);
+    BOOST_TEST(*it21 == 1);
+    BOOST_TEST(*it22 == 4);
+    BOOST_TEST(*it23 == 5);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2[1] == 4);
+    BOOST_TEST(cb2[2] == 5);
+    BOOST_TEST(cb2[3] == 2);
+    BOOST_TEST(cb2[4] == 3);
 
     // it24 -> 2, it25 -> 3
     circular_buffer<int>::iterator it24 = it21 + 3;
@@ -206,16 +206,16 @@ void validity_insert_range_test() {
 
     // memory placement: { 2, 3, 7, 4, 5 } - using input iterator inserts all items even if they are later replaced
     // circular buffer:  { 7, 4, 5, 2, 3 }
-    BOOST_CHECK(*it21 == 2);
-    BOOST_CHECK(*it22 == 3);
-    BOOST_CHECK(*it23 == 7);
-    BOOST_CHECK(*it24 == 4);
-    BOOST_CHECK(*it25 == 5);
-    BOOST_CHECK(cb2[0] == 7);
-    BOOST_CHECK(cb2[1] == 4);
-    BOOST_CHECK(cb2[2] == 5);
-    BOOST_CHECK(cb2[3] == 2);
-    BOOST_CHECK(cb2[4] == 3);
+    BOOST_TEST(*it21 == 2);
+    BOOST_TEST(*it22 == 3);
+    BOOST_TEST(*it23 == 7);
+    BOOST_TEST(*it24 == 4);
+    BOOST_TEST(*it25 == 5);
+    BOOST_TEST(cb2[0] == 7);
+    BOOST_TEST(cb2[1] == 4);
+    BOOST_TEST(cb2[2] == 5);
+    BOOST_TEST(cb2[3] == 2);
+    BOOST_TEST(cb2[4] == 3);
 }
 
 void validity_rinsert_test() {
@@ -235,13 +235,13 @@ void validity_rinsert_test() {
 
     // memory placement: { 2, 4, 3, 1 }
     // circular buffer:  { 1, 2, 4, 3 }
-    BOOST_CHECK(*it1 == 2);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 3);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 3);
+    BOOST_TEST(*it1 == 2);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 3);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 3);
 
     // it4 -> 1
     circular_buffer<int>::iterator it4 = it1 - 1;
@@ -250,14 +250,14 @@ void validity_rinsert_test() {
 
     // memory placement: { 5, 4, 1, 2 }
     // circular buffer:  { 1, 2, 5, 4 }
-    BOOST_CHECK(*it1 == 5);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 1);
-    BOOST_CHECK(*it4 == 2);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 5);
-    BOOST_CHECK(cb[3] == 4);
+    BOOST_TEST(*it1 == 5);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 1);
+    BOOST_TEST(*it4 == 2);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 5);
+    BOOST_TEST(cb[3] == 4);
 }
 
 void validity_rinsert_n_test() {
@@ -278,14 +278,14 @@ void validity_rinsert_n_test() {
 
     // memory placement: { 4, 4, 3, 1, 2 }
     // circular buffer:  { 1, 2, 4, 4, 3 }
-    BOOST_CHECK(*it1 == 4);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 3);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 4);
-    BOOST_CHECK(cb[4] == 3);
+    BOOST_TEST(*it1 == 4);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 3);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 4);
+    BOOST_TEST(cb[4] == 3);
 
     // it4 -> 1, it5 -> 2
     circular_buffer<int>::iterator it4 = it1 - 2;
@@ -295,16 +295,16 @@ void validity_rinsert_n_test() {
 
     // memory placement: { 4, 5, 1, 2, 4 } - 5 inserted only once
     // circular buffer:  { 1, 2, 4, 4, 5 }
-    BOOST_CHECK(*it1 == 4);
-    BOOST_CHECK(*it2 == 5);
-    BOOST_CHECK(*it3 == 1);
-    BOOST_CHECK(*it4 == 2);
-    BOOST_CHECK(*it5 == 4);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 4);
-    BOOST_CHECK(cb[4] == 5);
+    BOOST_TEST(*it1 == 4);
+    BOOST_TEST(*it2 == 5);
+    BOOST_TEST(*it3 == 1);
+    BOOST_TEST(*it4 == 2);
+    BOOST_TEST(*it5 == 4);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 4);
+    BOOST_TEST(cb[4] == 5);
 }
 
 void validity_rinsert_range_test() {
@@ -334,14 +334,14 @@ void validity_rinsert_range_test() {
 
     // memory placement: { 4, 5, 3, 1, 2 }
     // circular buffer:  { 1, 2, 4, 5, 3 }
-    BOOST_CHECK(*it11 == 4);
-    BOOST_CHECK(*it12 == 5);
-    BOOST_CHECK(*it13 == 3);
-    BOOST_CHECK(cb1[0] == 1);
-    BOOST_CHECK(cb1[1] == 2);
-    BOOST_CHECK(cb1[2] == 4);
-    BOOST_CHECK(cb1[3] == 5);
-    BOOST_CHECK(cb1[4] == 3);
+    BOOST_TEST(*it11 == 4);
+    BOOST_TEST(*it12 == 5);
+    BOOST_TEST(*it13 == 3);
+    BOOST_TEST(cb1[0] == 1);
+    BOOST_TEST(cb1[1] == 2);
+    BOOST_TEST(cb1[2] == 4);
+    BOOST_TEST(cb1[3] == 5);
+    BOOST_TEST(cb1[4] == 3);
 
     // it14 -> 1, it15 -> 2
     circular_buffer<int>::iterator it14 = it11 - 2;
@@ -351,16 +351,16 @@ void validity_rinsert_range_test() {
 
     // memory placement: { 5, 6, 1, 2, 4 } - 6 inserted only
     // circular buffer:  { 1, 2, 4, 5, 6 }
-    BOOST_CHECK(*it11 == 5);
-    BOOST_CHECK(*it12 == 6);
-    BOOST_CHECK(*it13 == 1);
-    BOOST_CHECK(*it14 == 2);
-    BOOST_CHECK(*it15 == 4);
-    BOOST_CHECK(cb1[0] == 1);
-    BOOST_CHECK(cb1[1] == 2);
-    BOOST_CHECK(cb1[2] == 4);
-    BOOST_CHECK(cb1[3] == 5);
-    BOOST_CHECK(cb1[4] == 6);
+    BOOST_TEST(*it11 == 5);
+    BOOST_TEST(*it12 == 6);
+    BOOST_TEST(*it13 == 1);
+    BOOST_TEST(*it14 == 2);
+    BOOST_TEST(*it15 == 4);
+    BOOST_TEST(cb1[0] == 1);
+    BOOST_TEST(cb1[1] == 2);
+    BOOST_TEST(cb1[2] == 4);
+    BOOST_TEST(cb1[3] == 5);
+    BOOST_TEST(cb1[4] == 6);
 
     // memory placement: { 1, 2, 3 }
     // circular buffer:  { 1, 2, 3 }
@@ -378,14 +378,14 @@ void validity_rinsert_range_test() {
 
     // memory placement: { 4, 5, 3, 1, 2 }
     // circular buffer:  { 1, 2, 4, 5, 3 }
-    BOOST_CHECK(*it21 == 4);
-    BOOST_CHECK(*it22 == 5);
-    BOOST_CHECK(*it23 == 3);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2[1] == 2);
-    BOOST_CHECK(cb2[2] == 4);
-    BOOST_CHECK(cb2[3] == 5);
-    BOOST_CHECK(cb2[4] == 3);
+    BOOST_TEST(*it21 == 4);
+    BOOST_TEST(*it22 == 5);
+    BOOST_TEST(*it23 == 3);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2[1] == 2);
+    BOOST_TEST(cb2[2] == 4);
+    BOOST_TEST(cb2[3] == 5);
+    BOOST_TEST(cb2[4] == 3);
 
     // it24 -> 1, it25 -> 2
     circular_buffer<int>::iterator it24 = it21 - 2;
@@ -395,16 +395,16 @@ void validity_rinsert_range_test() {
 
     // memory placement: { 5, 6, 1, 2, 4 }
     // circular buffer:  { 1, 2, 4, 5, 6 }
-    BOOST_CHECK(*it21 == 5);
-    BOOST_CHECK(*it22 == 6);
-    BOOST_CHECK(*it23 == 1);
-    BOOST_CHECK(*it24 == 2);
-    BOOST_CHECK(*it25 == 4);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2[1] == 2);
-    BOOST_CHECK(cb2[2] == 4);
-    BOOST_CHECK(cb2[3] == 5);
-    BOOST_CHECK(cb2[4] == 6);
+    BOOST_TEST(*it21 == 5);
+    BOOST_TEST(*it22 == 6);
+    BOOST_TEST(*it23 == 1);
+    BOOST_TEST(*it24 == 2);
+    BOOST_TEST(*it25 == 4);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2[1] == 2);
+    BOOST_TEST(cb2[2] == 4);
+    BOOST_TEST(cb2[3] == 5);
+    BOOST_TEST(cb2[4] == 6);
 }
 
 void validity_erase_test() {
@@ -430,14 +430,14 @@ void validity_erase_test() {
 
     // memory placement: { 5, X, 1, 3, 4 }
     // circular buffer:  { 1, 3, 4, 5 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 3);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(*it4 == 5);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 3);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 5);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 3);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(*it4 == 5);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 3);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 5);
 }
 
 void validity_erase_range_test() {
@@ -465,14 +465,14 @@ void validity_erase_range_test() {
 
     // memory placement: { 6, X, X, 1, 2, 5 }
     // circular buffer:  { 1, 2, 5, 6 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(*it3 == 5);
-    BOOST_CHECK(*it4 == 6);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 5);
-    BOOST_CHECK(cb[3] == 6);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(*it3 == 5);
+    BOOST_TEST(*it4 == 6);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 5);
+    BOOST_TEST(cb[3] == 6);
 }
 
 void validity_rerase_test() {
@@ -498,14 +498,14 @@ void validity_rerase_test() {
 
     // memory placement: { 4, 5, X, 1, 3 }
     // circular buffer:  { 1, 3, 4, 5 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 3);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(*it4 == 5);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 3);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 5);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 3);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(*it4 == 5);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 3);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 5);
 }
 
 void validity_rerase_range_test() {
@@ -533,14 +533,14 @@ void validity_rerase_range_test() {
 
     // memory placement: { 2, 5, 6, X, X, 1 }
     // circular buffer:  { 1, 2, 5, 6 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(*it3 == 5);
-    BOOST_CHECK(*it4 == 6);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 5);
-    BOOST_CHECK(cb[3] == 6);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(*it3 == 5);
+    BOOST_TEST(*it4 == 6);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 5);
+    BOOST_TEST(cb[3] == 6);
 }
 
 void validity_linearize_test() {
@@ -562,12 +562,12 @@ void validity_linearize_test() {
 
     // memory placement: { 1, 2, 3 }
     // circular buffer:  { 1, 2, 3 }
-    BOOST_CHECK(*it1 == 2);
-    BOOST_CHECK(*it2 == 3);
-    BOOST_CHECK(*it3 == 1);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 3);
+    BOOST_TEST(*it1 == 2);
+    BOOST_TEST(*it2 == 3);
+    BOOST_TEST(*it3 == 1);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 3);
 }
 
 void validity_swap_test() {
@@ -600,20 +600,20 @@ void validity_swap_test() {
     cb1.swap(cb2);
 
     // Although iterators refer to the original elements,
-    // their interal state is inconsistent and no other operation
+    // their internal state is inconsistent and no other operation
     // (except dereferencing) can be invoked on them any more.
-    BOOST_CHECK(*it11 == 1);
-    BOOST_CHECK(*it12 == 2);
-    BOOST_CHECK(*it13 == 3);
-    BOOST_CHECK(*it21 == 4);
-    BOOST_CHECK(*it22 == 5);
-    BOOST_CHECK(*it23 == 6);
-    BOOST_CHECK(cb1[0] == 4);
-    BOOST_CHECK(cb1[1] == 5);
-    BOOST_CHECK(cb1[2] == 6);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2[1] == 2);
-    BOOST_CHECK(cb2[2] == 3);
+    BOOST_TEST(*it11 == 1);
+    BOOST_TEST(*it12 == 2);
+    BOOST_TEST(*it13 == 3);
+    BOOST_TEST(*it21 == 4);
+    BOOST_TEST(*it22 == 5);
+    BOOST_TEST(*it23 == 6);
+    BOOST_TEST(cb1[0] == 4);
+    BOOST_TEST(cb1[1] == 5);
+    BOOST_TEST(cb1[2] == 6);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2[1] == 2);
+    BOOST_TEST(cb2[2] == 3);
 }
 
 void validity_push_back_test() {
@@ -635,12 +635,12 @@ void validity_push_back_test() {
 
     // memory placement: { 3, 4, 2 }
     // circular buffer:  { 2, 3, 4 }
-    BOOST_CHECK(*it1 == 4);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(*it3 == 3);
-    BOOST_CHECK(cb[0] == 2);
-    BOOST_CHECK(cb[1] == 3);
-    BOOST_CHECK(cb[2] == 4);
+    BOOST_TEST(*it1 == 4);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(*it3 == 3);
+    BOOST_TEST(cb[0] == 2);
+    BOOST_TEST(cb[1] == 3);
+    BOOST_TEST(cb[2] == 4);
 }
 
 void validity_push_front_test() {
@@ -662,12 +662,12 @@ void validity_push_front_test() {
 
     // memory placement: { 4, 1, 2 }
     // circular buffer:  { 4, 1, 2 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(cb[0] == 4);
-    BOOST_CHECK(cb[1] == 1);
-    BOOST_CHECK(cb[2] == 2);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(cb[0] == 4);
+    BOOST_TEST(cb[1] == 1);
+    BOOST_TEST(cb[2] == 2);
 }
 
 void validity_pop_back_test() {
@@ -688,10 +688,10 @@ void validity_pop_back_test() {
 
     // memory placement: { X, 1, 2 }
     // circular buffer:  { 1, 2 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
 }
 
 void validity_pop_front_test() {
@@ -712,34 +712,31 @@ void validity_pop_front_test() {
 
     // memory placement: { 3, X, 2 }
     // circular buffer:  { 2, 3 }
-    BOOST_CHECK(*it1 == 2);
-    BOOST_CHECK(*it2 == 3);
-    BOOST_CHECK(cb[0] == 2);
-    BOOST_CHECK(cb[1] == 3);
+    BOOST_TEST(*it1 == 2);
+    BOOST_TEST(*it2 == 3);
+    BOOST_TEST(cb[0] == 2);
+    BOOST_TEST(cb[1] == 3);
 }
 
 // test main
-test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
-
-    test_suite* tests = BOOST_TEST_SUITE("Unit tests for the iterator of the circular_buffer.");
-
-    tests->add(BOOST_TEST_CASE(&validity_example_test));
-    tests->add(BOOST_TEST_CASE(&validity_insert_test));
-    tests->add(BOOST_TEST_CASE(&validity_insert_n_test));
-    tests->add(BOOST_TEST_CASE(&validity_insert_range_test));
-    tests->add(BOOST_TEST_CASE(&validity_rinsert_test));
-    tests->add(BOOST_TEST_CASE(&validity_rinsert_n_test));
-    tests->add(BOOST_TEST_CASE(&validity_rinsert_range_test));
-    tests->add(BOOST_TEST_CASE(&validity_erase_test));
-    tests->add(BOOST_TEST_CASE(&validity_erase_range_test));
-    tests->add(BOOST_TEST_CASE(&validity_rerase_test));
-    tests->add(BOOST_TEST_CASE(&validity_rerase_range_test));
-    tests->add(BOOST_TEST_CASE(&validity_linearize_test));
-    tests->add(BOOST_TEST_CASE(&validity_swap_test));
-    tests->add(BOOST_TEST_CASE(&validity_push_back_test));
-    tests->add(BOOST_TEST_CASE(&validity_push_front_test));
-    tests->add(BOOST_TEST_CASE(&validity_pop_back_test));
-    tests->add(BOOST_TEST_CASE(&validity_pop_front_test));
-
-    return tests;
+int main()
+{
+    validity_example_test();
+    validity_insert_test();
+    validity_insert_n_test();
+    validity_insert_range_test();
+    validity_rinsert_test();
+    validity_rinsert_n_test();
+    validity_rinsert_range_test();
+    validity_erase_test();
+    validity_erase_range_test();
+    validity_rerase_test();
+    validity_rerase_range_test();
+    validity_linearize_test();
+    validity_swap_test();
+    validity_push_back_test();
+    validity_push_front_test();
+    validity_pop_back_test();
+    validity_pop_front_test();
+    return boost::report_errors();
 }

test/space_optimized_test.cpp

@@ -29,33 +29,33 @@ void min_capacity_test() {
     cb_space_optimized cb2(capacity_ctrl(10, 5), 1);
     cb_space_optimized cb3(capacity_ctrl(20, 10), v.begin(), v.end());
 
-    BOOST_CHECK(cb1.size() == 0);
-    BOOST_CHECK(cb1.capacity().capacity() == 10);
-    BOOST_CHECK(cb1.capacity().min_capacity() == 10);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2.size() == 10);
-    BOOST_CHECK(cb2.capacity() == 10);
-    BOOST_CHECK(cb2.capacity().min_capacity() == 5);
-    BOOST_CHECK(cb3[0] == 1);
-    BOOST_CHECK(cb3.size() == 5);
-    BOOST_CHECK(cb3.capacity() == 20);
-    BOOST_CHECK(cb3.capacity().min_capacity() == 10);
-    BOOST_CHECK(cb1.capacity().min_capacity() <= cb1.internal_capacity());
-    BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
-    BOOST_CHECK(cb3.capacity().min_capacity() <= cb3.internal_capacity());
+    BOOST_TEST(cb1.size() == 0);
+    BOOST_TEST(cb1.capacity().capacity() == 10);
+    BOOST_TEST(cb1.capacity().min_capacity() == 10);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2.size() == 10);
+    BOOST_TEST(cb2.capacity() == 10);
+    BOOST_TEST(cb2.capacity().min_capacity() == 5);
+    BOOST_TEST(cb3[0] == 1);
+    BOOST_TEST(cb3.size() == 5);
+    BOOST_TEST(cb3.capacity() == 20);
+    BOOST_TEST(cb3.capacity().min_capacity() == 10);
+    BOOST_TEST(cb1.capacity().min_capacity() <= cb1.internal_capacity());
+    BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
+    BOOST_TEST(cb3.capacity().min_capacity() <= cb3.internal_capacity());
 
     cb2.erase(cb2.begin() + 2, cb2.end());
 
-    BOOST_CHECK(cb2.size() == 2);
-    BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
+    BOOST_TEST(cb2.size() == 2);
+    BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
 
     cb2.clear();
     cb3.clear();
 
-    BOOST_CHECK(cb2.empty());
-    BOOST_CHECK(cb3.empty());
-    BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
-    BOOST_CHECK(cb3.capacity().min_capacity() <= cb3.internal_capacity());
+    BOOST_TEST(cb2.empty());
+    BOOST_TEST(cb3.empty());
+    BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
+    BOOST_TEST(cb3.capacity().min_capacity() <= cb3.internal_capacity());
 }
 
 void capacity_control_test() {
@@ -65,33 +65,33 @@ void capacity_control_test() {
     circular_buffer_space_optimized<int>::capacity_type(20, 5);
     circular_buffer_space_optimized<int>::capacity_type c3 = c2;
 
-    BOOST_CHECK(c1.capacity() == 10);
-    BOOST_CHECK(c1.min_capacity() == 0);
-    BOOST_CHECK(c2.capacity() == 20);
-    BOOST_CHECK(c2.min_capacity() == 5);
-    BOOST_CHECK(c3.capacity() == 20);
-    BOOST_CHECK(c3.min_capacity() == 5);
+    BOOST_TEST(c1.capacity() == 10);
+    BOOST_TEST(c1.min_capacity() == 0);
+    BOOST_TEST(c2.capacity() == 20);
+    BOOST_TEST(c2.min_capacity() == 5);
+    BOOST_TEST(c3.capacity() == 20);
+    BOOST_TEST(c3.min_capacity() == 5);
 
     c1 = c2;
 
-    BOOST_CHECK(c1.capacity() == 20);
-    BOOST_CHECK(c1.min_capacity() == 5);
+    BOOST_TEST(c1.capacity() == 20);
+    BOOST_TEST(c1.min_capacity() == 5);
 }
 
 void specific_constructors_test() {
 
     cb_space_optimized cb1;
-    BOOST_CHECK(cb1.capacity() == 0);
-    BOOST_CHECK(cb1.capacity().min_capacity() == 0);
-    BOOST_CHECK(cb1.internal_capacity() == 0);
-    BOOST_CHECK(cb1.size() == 0);
+    BOOST_TEST(cb1.capacity() == 0);
+    BOOST_TEST(cb1.capacity().min_capacity() == 0);
+    BOOST_TEST(cb1.internal_capacity() == 0);
+    BOOST_TEST(cb1.size() == 0);
 
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
 
-    BOOST_CHECK(cb1.size() == 0);
-    BOOST_CHECK(cb1.capacity() == 0);
+    BOOST_TEST(cb1.size() == 0);
+    BOOST_TEST(cb1.capacity() == 0);
 
     vector<int> v;
     v.push_back(1);
@@ -100,9 +100,9 @@ void specific_constructors_test() {
 
     cb_space_optimized cb2(v.begin(), v.end());
 
-    BOOST_CHECK(cb2.capacity() == 3);
-    BOOST_CHECK(cb2.capacity().min_capacity() == 0);
-    BOOST_CHECK(cb2.size() == 3);
+    BOOST_TEST(cb2.capacity() == 3);
+    BOOST_TEST(cb2.capacity().min_capacity() == 0);
+    BOOST_TEST(cb2.size() == 3);
 }
 
 void shrink_to_fit_test() {
@@ -112,15 +112,15 @@ void shrink_to_fit_test() {
     cb.push_back(2);
     cb.push_back(3);
 
-    BOOST_CHECK(cb.size() == 3);
-    BOOST_CHECK(cb.capacity() == 1000);
+    BOOST_TEST(cb.size() == 3);
+    BOOST_TEST(cb.capacity() == 1000);
 
     size_t internal_capacity = cb.internal_capacity();
     cb_space_optimized(cb).swap(cb);
 
-    BOOST_CHECK(cb.size() == 3);
-    BOOST_CHECK(cb.capacity() == 1000);
-    BOOST_CHECK(internal_capacity >= cb.internal_capacity());
+    BOOST_TEST(cb.size() == 3);
+    BOOST_TEST(cb.capacity() == 1000);
+    BOOST_TEST(internal_capacity >= cb.internal_capacity());
 }
 
 void iterator_invalidation_test() {
@@ -136,33 +136,33 @@ void iterator_invalidation_test() {
     cb_space_optimized::iterator it3 = cb1.begin() + 6;
 
     cb1.set_capacity(10);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
     it1 = cb1.end();
     it2 = cb1.begin();
     it3 = cb1.begin() + 6;
     cb1.rset_capacity(10);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
     it1 = cb1.end();
     it2 = cb1.begin();
     it3 = cb1.begin() + 6;
     cb1.resize(10);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
     it1 = cb1.end();
     it2 = cb1.begin();
     it3 = cb1.begin() + 6;
     cb1.rresize(10);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
     {
         cb_space_optimized cb2(10, 1);
@@ -173,24 +173,21 @@ void iterator_invalidation_test() {
         it2 = cb2.begin();
         it3 = cb2.begin() + 6;
     }
-    BOOST_CHECK(!it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(!it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
 #endif // #if BOOST_CB_ENABLE_DEBUG
 }
 
 // test main
-test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
-
-    test_suite* tests = BOOST_TEST_SUITE("Unit tests for the circular_buffer_space_optimized.");
-    add_common_tests(tests);
-
-    tests->add(BOOST_TEST_CASE(&min_capacity_test));
-    tests->add(BOOST_TEST_CASE(&capacity_control_test));
-    tests->add(BOOST_TEST_CASE(&specific_constructors_test));
-    tests->add(BOOST_TEST_CASE(&shrink_to_fit_test));
-    tests->add(BOOST_TEST_CASE(&iterator_invalidation_test));
-
-    return tests;
+int main()
+{
+    run_common_tests();
+    min_capacity_test();
+    capacity_control_test();
+    specific_constructors_test();
+    shrink_to_fit_test();
+    iterator_invalidation_test();
+    return boost::report_errors();
 }

test/test.hpp

@@ -16,8 +16,7 @@
 #define BOOST_CB_TEST
 
 #include <boost/circular_buffer.hpp>
-#include <boost/test/included/unit_test.hpp>
-#include <boost/iterator.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iterator>
 #include <numeric>
 #include <vector>
@@ -90,6 +89,7 @@ public:
         eVirtual
     };
     Dummy() : m_n(eVar) {}
+    virtual ~Dummy() {}
     DummyEnum fnc() { return eFnc; }
     DummyEnum const_fnc() const { return eConst; }
     virtual DummyEnum virtual_fnc() { return eVirtual; }
@@ -97,9 +97,9 @@ public:
 };
 
 // simulator of an input iterator
-struct MyInputIterator
-: boost::iterator<std::input_iterator_tag, int, ptrdiff_t, int*, int&> {
+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;
@@ -139,7 +139,6 @@ inline ptrdiff_t* distance_type(const MyInputIterator&) { return 0; }
 
 #endif // #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR)
 
-using boost::unit_test::test_suite;
 using namespace boost;
 using namespace std;