1 // Header file for the test of the circular buffer library. 2 3 // Copyright (c) 2003-2008 Jan Gaspar 4 5 // Use, modification, and distribution is subject to the Boost Software 6 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 7 // http://www.boost.org/LICENSE_1_0.txt) 8 9 #if !defined(BOOST_CIRCULAR_BUFFER_TEST_HPP) 10 #define BOOST_CIRCULAR_BUFFER_TEST_HPP 11 12 #if defined(_MSC_VER) && _MSC_VER >= 1200 13 #pragma once 14 #endif 15 16 #define BOOST_CB_TEST 17 18 #include <boost/circular_buffer.hpp> 19 #include <boost/core/lightweight_test.hpp> 20 #include <iterator> 21 #include <numeric> 22 #include <vector> 23 #if !defined(BOOST_NO_EXCEPTIONS) 24 #include <exception> 25 #endif 26 27 // Integer (substitute for int) - more appropriate for testing 28 class MyInteger { 29 private: 30 int* m_pValue; 31 static int ms_exception_trigger; check_exception()32 void check_exception() { 33 if (ms_exception_trigger > 0) { 34 if (--ms_exception_trigger == 0) { 35 delete m_pValue; 36 m_pValue = 0; 37 #if !defined(BOOST_NO_EXCEPTIONS) 38 throw std::exception(); 39 #endif 40 } 41 } 42 } 43 public: MyInteger()44 MyInteger() : m_pValue(new int(0)) { check_exception(); } MyInteger(int i)45 MyInteger(int i) : m_pValue(new int(i)) { check_exception(); } MyInteger(const MyInteger & src)46 MyInteger(const MyInteger& src) : m_pValue(new int(src)) { check_exception(); } ~MyInteger()47 ~MyInteger() { delete m_pValue; } operator =(const MyInteger & src)48 MyInteger& operator = (const MyInteger& src) { 49 if (this == &src) 50 return *this; 51 check_exception(); 52 delete m_pValue; 53 m_pValue = new int(src); 54 return *this; 55 } operator int() const56 operator int () const { return *m_pValue; } set_exception_trigger(int n)57 static void set_exception_trigger(int n) { ms_exception_trigger = n; } 58 }; 59 60 // default constructible class 61 class MyDefaultConstructible 62 { 63 public: MyDefaultConstructible()64 MyDefaultConstructible() : m_n(1) {} MyDefaultConstructible(int n)65 MyDefaultConstructible(int n) : m_n(n) {} 66 int m_n; 67 }; 68 69 // class counting instances of self 70 class InstanceCounter { 71 public: InstanceCounter()72 InstanceCounter() { increment(); } InstanceCounter(const InstanceCounter & y)73 InstanceCounter(const InstanceCounter& y) { y.increment(); } ~InstanceCounter()74 ~InstanceCounter() { decrement(); } count()75 static int count() { return ms_count; } 76 private: increment() const77 void increment() const { ++ms_count; } decrement() const78 void decrement() const { --ms_count; } 79 static int ms_count; 80 }; 81 82 // dummy class suitable for iterator referencing test 83 class Dummy { 84 public: 85 enum DummyEnum { 86 eVar, 87 eFnc, 88 eConst, 89 eVirtual 90 }; Dummy()91 Dummy() : m_n(eVar) {} ~Dummy()92 virtual ~Dummy() {} fnc()93 DummyEnum fnc() { return eFnc; } const_fnc() const94 DummyEnum const_fnc() const { return eConst; } virtual_fnc()95 virtual DummyEnum virtual_fnc() { return eVirtual; } 96 DummyEnum m_n; 97 }; 98 99 // simulator of an input iterator 100 struct MyInputIterator { 101 typedef std::vector<int>::iterator vector_iterator; 102 typedef std::input_iterator_tag iterator_category; 103 typedef int value_type; 104 typedef int* pointer; 105 typedef int& reference; 106 typedef size_t size_type; 107 typedef ptrdiff_t difference_type; MyInputIteratorMyInputIterator108 explicit MyInputIterator(const vector_iterator& it) : m_it(it) {} operator =MyInputIterator109 MyInputIterator& operator = (const MyInputIterator& it) { 110 if (this == &it) 111 return *this; 112 m_it = it.m_it; 113 return *this; 114 } operator *MyInputIterator115 reference operator * () const { return *m_it; } operator ->MyInputIterator116 pointer operator -> () const { return &(operator*()); } operator ++MyInputIterator117 MyInputIterator& operator ++ () { 118 ++m_it; 119 return *this; 120 } operator ++MyInputIterator121 MyInputIterator operator ++ (int) { 122 MyInputIterator tmp = *this; 123 ++*this; 124 return tmp; 125 } operator ==MyInputIterator126 bool operator == (const MyInputIterator& it) const { return m_it == it.m_it; } operator !=MyInputIterator127 bool operator != (const MyInputIterator& it) const { return m_it != it.m_it; } 128 private: 129 vector_iterator m_it; 130 }; 131 132 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) 133 iterator_category(const MyInputIterator &)134inline std::input_iterator_tag iterator_category(const MyInputIterator&) { 135 return std::input_iterator_tag(); 136 } value_type(const MyInputIterator &)137inline int* value_type(const MyInputIterator&) { return 0; } distance_type(const MyInputIterator &)138inline ptrdiff_t* distance_type(const MyInputIterator&) { return 0; } 139 140 #endif // #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) 141 142 using namespace boost; 143 using namespace std; 144 145 #endif // #if !defined(BOOST_CIRCULAR_BUFFER_TEST_HPP) 146