[Boost-commit] svn:boost r42711 - branches/unordered/trunk/libs/unordered/test/objects

From: daniel_james_at_[hidden]
Date: 2008-01-12 18:19:19

Author: danieljames
Date: 2008-01-12 18:19:19 EST (Sat, 12 Jan 2008)
New Revision: 42711
URL: http://svn.boost.org/trac/boost/changeset/42711

Log:
Clean up the unordered exception testing code a little. Rely on the shared test
headers and use a namespace for macros.

Text files modified: 
   branches/unordered/trunk/libs/unordered/test/objects/exception.hpp |   191 +++++++++++++++++++-------------------- 
   1 files changed, 92 insertions(+), 99 deletions(-)

Modified: branches/unordered/trunk/libs/unordered/test/objects/exception.hpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/objects/exception.hpp	(original)
+++ branches/unordered/trunk/libs/unordered/test/objects/exception.hpp	2008-01-12 18:19:19 EST (Sat, 12 Jan 2008)
@@ -6,13 +6,12 @@
 #if !defined(BOOST_UNORDERED_TEST_OBJECTS_HEADER)
 #define BOOST_UNORDERED_TEST_OBJECTS_HEADER
 
+#include "../helpers/test.hpp"
+
 #if defined(BOOST_UNORDERED_USE_TEST)
-#define BOOST_TEST_MAIN
-#include <boost/test/exception_safety.hpp>
-#include <boost/test/test_tools.hpp>
-#include <boost/test/unit_test.hpp>
-#else
-#include <boost/detail/lightweight_test.hpp>
+#   define BOOST_TEST_MAIN
+#   include <boost/test/exception_safety.hpp>
+#   include <boost/test/unit_test.hpp>
 #endif
 
 #include <cstddef>
@@ -25,6 +24,27 @@
 #include "../helpers/allocator.hpp"
 #include "./memory.hpp"
 
+#if defined(BOOST_UNORDERED_USE_TEST)
+#   define UNORDERED_EXCEPTION_TEST_PREFIX
+#   define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
+        BOOST_AUTO_TEST_CASE(name) \
+        { \
+            test_func< type > fixture; \
+            ::test::exception_safety(fixture, BOOST_STRINGIZE(test_func<type>)); \
+        }
+#    define UNORDERED_EXCEPTION_TEST_POSTFIX
+#    define UNORDERED_EPOINT_IMPL BOOST_ITEST_EPOINT
+#else
+#    define UNORDERED_EXCEPTION_TEST_PREFIX int main() {
+#    define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
+        { \
+            test_func< type > fixture; \
+            ::test::lightweight::exception_safety(fixture, BOOST_STRINGIZE(test_func<type>)); \
+        }
+#    define UNORDERED_EXCEPTION_TEST_POSTFIX return boost::report_errors(); }
+#    define UNORDERED_EPOINT_IMPL ::test::lightweight::epoint
+#endif
+
 #define RUN_EXCEPTION_TESTS(test_seq, param_seq) \
     UNORDERED_EXCEPTION_TEST_PREFIX \
     BOOST_PP_SEQ_FOR_EACH_PRODUCT(RUN_EXCEPTION_TESTS_OP, (test_seq)(param_seq)) \
@@ -39,43 +59,16 @@
         BOOST_PP_SEQ_ELEM(1, product) \
     )
 
-
-#if defined(BOOST_UNORDERED_USE_TEST)
-#define UNORDERED_EXCEPTION_TEST_PREFIX
-#define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
-    BOOST_AUTO_TEST_CASE(name) \
-    { \
-        test_func< type > fixture; \
-        ::test::exception_safety(fixture, BOOST_STRINGIZE(test_func<type>)); \
-    }
-#define UNORDERED_EXCEPTION_TEST_POSTFIX
-#else
-#define UNORDERED_EXCEPTION_TEST_PREFIX int main() {
-#define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
-    { \
-        test_func< type > fixture; \
-        ::test::lightweight::exception_safety(fixture, BOOST_STRINGIZE(test_func<type>)); \
-    }
-#define UNORDERED_EXCEPTION_TEST_POSTFIX return boost::report_errors(); }
-#endif
-
-#define SCOPE(scope_name) \
+#define UNORDERED_SCOPE(scope_name) \
     for(::test::scope_guard unordered_test_guard( \
             BOOST_STRINGIZE(scope_name)); \
         !unordered_test_guard.dismissed(); \
         unordered_test_guard.dismiss())
 
-#if defined(BOOST_UNORDERED_USE_TEST)
-#define EPOINT(name) \
+#define UNORDERED_EPOINT(name) \
     if(::test::exceptions_enabled) { \
-        BOOST_ITEST_EPOINT(name); \
+        UNORDERED_EPOINT_IMPL(name); \
     }
-#else
-#define EPOINT(name) \
-    if(::test::exceptions_enabled) { \
-        ::test::lightweight::epoint(name); \
-    }
-#endif
 
 #define ENABLE_EXCEPTIONS \
     ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(true)
@@ -280,23 +273,23 @@
 
         explicit object() : tag1_(0), tag2_(0)
         {
-            SCOPE(object::object()) {
-                EPOINT("Mock object default constructor.");
+            UNORDERED_SCOPE(object::object()) {
+                UNORDERED_EPOINT("Mock object default constructor.");
             }
         }
 
         explicit object(int t1, int t2 = 0) : tag1_(t1), tag2_(t2)
         {
-            SCOPE(object::object(int)) {
-                EPOINT("Mock object constructor by value.");
+            UNORDERED_SCOPE(object::object(int)) {
+                UNORDERED_EPOINT("Mock object constructor by value.");
             }
         }
 
         object(object const& x)
              : tag1_(x.tag1_), tag2_(x.tag2_)
         {
-            SCOPE(object::object(object)) {
-                EPOINT("Mock object copy constructor.");
+            UNORDERED_SCOPE(object::object(object)) {
+                UNORDERED_EPOINT("Mock object copy constructor.");
             }
         }
 
@@ -307,26 +300,26 @@
 
         object& operator=(object const& x)
         {
-            SCOPE(object::operator=(object)) {
+            UNORDERED_SCOPE(object::operator=(object)) {
                 tag1_ = x.tag1_;
-                EPOINT("Mock object assign operator 1.");
+                UNORDERED_EPOINT("Mock object assign operator 1.");
                 tag2_ = x.tag2_;
-                //EPOINT("Mock object assign operator 2.");
+                //UNORDERED_EPOINT("Mock object assign operator 2.");
             }
             return *this;
         }
 
         friend bool operator==(object const& x1, object const& x2) {
-            SCOPE(operator==(object, object)) {
-                EPOINT("Mock object equality operator.");
+            UNORDERED_SCOPE(operator==(object, object)) {
+                UNORDERED_EPOINT("Mock object equality operator.");
             }
 
             return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
         }
 
         friend bool operator!=(object const& x1, object const& x2) {
-            SCOPE(operator!=(object, object)) {
-                EPOINT("Mock object inequality operator.");
+            UNORDERED_SCOPE(operator!=(object, object)) {
+                UNORDERED_EPOINT("Mock object inequality operator.");
             }
 
             return !(x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_);
@@ -356,32 +349,32 @@
     public:
         hash(int t = 0) : tag_(t)
         {
-            SCOPE(hash::object()) {
-                EPOINT("Mock hash default constructor.");
+            UNORDERED_SCOPE(hash::object()) {
+                UNORDERED_EPOINT("Mock hash default constructor.");
             }
         }
 
         hash(hash const& x)
             : tag_(x.tag_)
         {
-            SCOPE(hash::hash(hash)) {
-                EPOINT("Mock hash copy constructor.");
+            UNORDERED_SCOPE(hash::hash(hash)) {
+                UNORDERED_EPOINT("Mock hash copy constructor.");
             }
         }
 
         hash& operator=(hash const& x)
         {
-            SCOPE(hash::operator=(hash)) {
-                EPOINT("Mock hash assign operator 1.");
+            UNORDERED_SCOPE(hash::operator=(hash)) {
+                UNORDERED_EPOINT("Mock hash assign operator 1.");
                 tag_ = x.tag_;
-                EPOINT("Mock hash assign operator 2.");
+                UNORDERED_EPOINT("Mock hash assign operator 2.");
             }
             return *this;
         }
 
         std::size_t operator()(object const& x) const {
-            SCOPE(hash::operator()(object)) {
-                EPOINT("Mock hash function.");
+            UNORDERED_SCOPE(hash::operator()(object)) {
+                UNORDERED_EPOINT("Mock hash function.");
             }
 
             switch(tag_) {
@@ -395,15 +388,15 @@
         }
 
         friend bool operator==(hash const& x1, hash const& x2) {
-            SCOPE(operator==(hash, hash)) {
-                EPOINT("Mock hash equality function.");
+            UNORDERED_SCOPE(operator==(hash, hash)) {
+                UNORDERED_EPOINT("Mock hash equality function.");
             }
             return x1.tag_ == x2.tag_;
         }
 
         friend bool operator!=(hash const& x1, hash const& x2) {
-            SCOPE(hash::operator!=(hash, hash)) {
-                EPOINT("Mock hash inequality function.");
+            UNORDERED_SCOPE(hash::operator!=(hash, hash)) {
+                UNORDERED_EPOINT("Mock hash inequality function.");
             }
             return x1.tag_ != x2.tag_;
         }
@@ -415,32 +408,32 @@
     public:
         equal_to(int t = 0) : tag_(t)
         {
-            SCOPE(equal_to::equal_to()) {
-                EPOINT("Mock equal_to default constructor.");
+            UNORDERED_SCOPE(equal_to::equal_to()) {
+                UNORDERED_EPOINT("Mock equal_to default constructor.");
             }
         }
 
         equal_to(equal_to const& x)
             : tag_(x.tag_)
         {
-            SCOPE(equal_to::equal_to(equal_to)) {
-                EPOINT("Mock equal_to copy constructor.");
+            UNORDERED_SCOPE(equal_to::equal_to(equal_to)) {
+                UNORDERED_EPOINT("Mock equal_to copy constructor.");
             }
         }
 
         equal_to& operator=(equal_to const& x)
         {
-            SCOPE(equal_to::operator=(equal_to)) {
-                EPOINT("Mock equal_to assign operator 1.");
+            UNORDERED_SCOPE(equal_to::operator=(equal_to)) {
+                UNORDERED_EPOINT("Mock equal_to assign operator 1.");
                 tag_ = x.tag_;
-                EPOINT("Mock equal_to assign operator 2.");
+                UNORDERED_EPOINT("Mock equal_to assign operator 2.");
             }
             return *this;
         }
 
         bool operator()(object const& x1, object const& x2) const {
-            SCOPE(equal_to::operator()(object, object)) {
-                EPOINT("Mock equal_to function.");
+            UNORDERED_SCOPE(equal_to::operator()(object, object)) {
+                UNORDERED_EPOINT("Mock equal_to function.");
             }
 
             switch(tag_) {
@@ -454,15 +447,15 @@
         }
 
         friend bool operator==(equal_to const& x1, equal_to const& x2) {
-            SCOPE(operator==(equal_to, equal_to)) {
-                EPOINT("Mock equal_to equality function.");
+            UNORDERED_SCOPE(operator==(equal_to, equal_to)) {
+                UNORDERED_EPOINT("Mock equal_to equality function.");
             }
             return x1.tag_ == x2.tag_;
         }
 
         friend bool operator!=(equal_to const& x1, equal_to const& x2) {
-            SCOPE(operator!=(equal_to, equal_to)) {
-                EPOINT("Mock equal_to inequality function.");
+            UNORDERED_SCOPE(operator!=(equal_to, equal_to)) {
+                UNORDERED_EPOINT("Mock equal_to inequality function.");
             }
             return x1.tag_ != x2.tag_;
         }
@@ -485,24 +478,24 @@
 
         explicit allocator(int t = 0) : tag_(t)
         {
-            SCOPE(allocator::allocator()) {
-                EPOINT("Mock allocator default constructor.");
+            UNORDERED_SCOPE(allocator::allocator()) {
+                UNORDERED_EPOINT("Mock allocator default constructor.");
             }
             detail::tracker.allocator_ref();
         }
 
         template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
         {
-            SCOPE(allocator::allocator()) {
-                EPOINT("Mock allocator template copy constructor.");
+            UNORDERED_SCOPE(allocator::allocator()) {
+                UNORDERED_EPOINT("Mock allocator template copy constructor.");
             }
             detail::tracker.allocator_ref();
         }
 
         allocator(allocator const& x) : tag_(x.tag_)
         {
-            SCOPE(allocator::allocator()) {
-                EPOINT("Mock allocator copy constructor.");
+            UNORDERED_SCOPE(allocator::allocator()) {
+                UNORDERED_EPOINT("Mock allocator copy constructor.");
             }
             detail::tracker.allocator_ref();
         }
@@ -512,8 +505,8 @@
         }
 
         allocator& operator=(allocator const& x) {
-            SCOPE(allocator::allocator()) {
-                EPOINT("Mock allocator assignment operator.");
+            UNORDERED_SCOPE(allocator::allocator()) {
+                UNORDERED_EPOINT("Mock allocator assignment operator.");
                 tag_ = x.tag_;
             }
             return *this;
@@ -524,23 +517,23 @@
         // this.
 
         pointer address(reference r) {
-            //SCOPE(allocator::address(reference)) {
-            //    EPOINT("Mock allocator address function.");
+            //UNORDERED_SCOPE(allocator::address(reference)) {
+            //    UNORDERED_EPOINT("Mock allocator address function.");
             //}
             return pointer(&r);
         }
 
         const_pointer address(const_reference r)  {
-            //SCOPE(allocator::address(const_reference)) {
-            //    EPOINT("Mock allocator const address function.");
+            //UNORDERED_SCOPE(allocator::address(const_reference)) {
+            //    UNORDERED_EPOINT("Mock allocator const address function.");
             //}
             return const_pointer(&r);
         }
 
         pointer allocate(size_type n) {
             T* ptr = 0;
-            SCOPE(allocator::allocate(size_type)) {
-                EPOINT("Mock allocator allocate function.");
+            UNORDERED_SCOPE(allocator::allocate(size_type)) {
+                UNORDERED_EPOINT("Mock allocator allocate function.");
 
                 using namespace std;
                 ptr = (T*) malloc(n * sizeof(T));
@@ -555,8 +548,8 @@
         pointer allocate(size_type n, const_pointer u)
         {
             T* ptr = 0;
-            SCOPE(allocator::allocate(size_type, const_pointer)) {
-                EPOINT("Mock allocator allocate function.");
+            UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer)) {
+                UNORDERED_EPOINT("Mock allocator allocate function.");
 
                 using namespace std;
                 ptr = (T*) malloc(n * sizeof(T));
@@ -579,8 +572,8 @@
         }
 
         void construct(pointer p, T const& t) {
-            SCOPE(allocator::construct(pointer, T)) {
-                EPOINT("Mock allocator construct function.");
+            UNORDERED_SCOPE(allocator::construct(pointer, T)) {
+                UNORDERED_EPOINT("Mock allocator construct function.");
                 new(p) T(t);
             }
             detail::tracker.track_construct((void*) p, sizeof(T), tag_);
@@ -592,8 +585,8 @@
         }
 
         size_type max_size() const {
-            SCOPE(allocator::construct(pointer, T)) {
-                EPOINT("Mock allocator max_size function.");
+            UNORDERED_SCOPE(allocator::construct(pointer, T)) {
+                UNORDERED_EPOINT("Mock allocator max_size function.");
             }
             return (std::numeric_limits<std::size_t>::max)();
         }
@@ -611,8 +604,8 @@
     template <class T>
     inline bool operator==(allocator<T> const& x, allocator<T> const& y)
     {
-        //SCOPE(operator==(allocator, allocator)) {
-        //    EPOINT("Mock allocator equality operator.");
+        //UNORDERED_SCOPE(operator==(allocator, allocator)) {
+        //    UNORDERED_EPOINT("Mock allocator equality operator.");
         //}
         return x.tag_ == y.tag_;
     }
@@ -620,8 +613,8 @@
     template <class T>
     inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
     {
-        //SCOPE(operator!=(allocator, allocator)) {
-        //    EPOINT("Mock allocator inequality operator.");
+        //UNORDERED_SCOPE(operator!=(allocator, allocator)) {
+        //    UNORDERED_EPOINT("Mock allocator inequality operator.");
         //}
         return x.tag_ != y.tag_;
     }