[Boost-commit] svn:boost r42718 - in branches/unordered/trunk/libs/unordered/test: helpers objects

From: daniel_james_at_[hidden]
Date: 2008-01-13 09:44:59

Author: danieljames
Date: 2008-01-13 09:44:59 EST (Sun, 13 Jan 2008)
New Revision: 42718
URL: http://svn.boost.org/trac/boost/changeset/42718

Log:
Move the exception stuff out of the objects directory where it never belonged.
The directory setup isn't that great but it'll do for now.

Added:
   branches/unordered/trunk/libs/unordered/test/helpers/exception_test.hpp   (contents, props changed)
Text files modified: 
   branches/unordered/trunk/libs/unordered/test/objects/exception.hpp |   230 --------------------------------------- 
   1 files changed, 1 insertions(+), 229 deletions(-)

Added: branches/unordered/trunk/libs/unordered/test/helpers/exception_test.hpp
==============================================================================
--- (empty file)
+++ branches/unordered/trunk/libs/unordered/test/helpers/exception_test.hpp	2008-01-13 09:44:59 EST (Sun, 13 Jan 2008)
@@ -0,0 +1,238 @@
+
+// Copyright 2006-2007 Daniel James.
+// 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)
+
+#if !defined(BOOST_UNORDERED_EXCEPTION_TEST_HEADER)
+#define BOOST_UNORDERED_EXCEPTION_TEST_HEADER
+
+#include "./test.hpp"
+
+#if defined(BOOST_UNORDERED_USE_TEST)
+#   define BOOST_TEST_MAIN
+#   include <boost/test/exception_safety.hpp>
+#   include <boost/test/unit_test.hpp>
+#endif
+
+#include <boost/preprocessor/seq/for_each_product.hpp>
+#include <boost/preprocessor/seq/elem.hpp>
+#include <boost/preprocessor/cat.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)) \
+    UNORDERED_EXCEPTION_TEST_POSTFIX
+
+#define RUN_EXCEPTION_TESTS_OP(r, product) \
+    UNORDERED_EXCEPTION_TEST_CASE( \
+        BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product), \
+            BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(1, product)) \
+        ), \
+        BOOST_PP_SEQ_ELEM(0, product), \
+        BOOST_PP_SEQ_ELEM(1, product) \
+    )
+
+#define UNORDERED_SCOPE(scope_name) \
+    for(::test::scope_guard unordered_test_guard( \
+            BOOST_STRINGIZE(scope_name)); \
+        !unordered_test_guard.dismissed(); \
+        unordered_test_guard.dismiss())
+
+#define UNORDERED_EPOINT(name) \
+    if(::test::exceptions_enabled) { \
+        UNORDERED_EPOINT_IMPL(name); \
+    }
+
+#define ENABLE_EXCEPTIONS \
+    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(true)
+#define DISABLE_EXCEPTIONS \
+    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(false)
+
+namespace test {
+    static char const* scope = "";
+    bool exceptions_enabled = false;
+
+    class scope_guard {
+        scope_guard& operator=(scope_guard const&);
+        scope_guard(scope_guard const&);
+
+        char const* old_scope_;
+        char const* scope_;
+        bool dismissed_;
+    public:
+        scope_guard(char const* name)
+            : old_scope_(scope),
+            scope_(name),
+            dismissed_(false)
+        {
+            scope = scope_;
+        }
+
+        ~scope_guard() {
+            if(dismissed_) scope = old_scope_;
+        }
+
+        void dismiss() {
+            dismissed_ = true;
+        }
+
+        bool dismissed() const {
+            return dismissed_;
+        }
+    };
+
+    class exceptions_enable
+    {
+        exceptions_enable& operator=(exceptions_enable const&);
+        exceptions_enable(exceptions_enable const&);
+
+        bool old_value_;
+    public:
+        exceptions_enable(bool enable)
+            : old_value_(exceptions_enabled)
+        {
+            exceptions_enabled = enable;
+        }
+
+        ~exceptions_enable()
+        {
+            exceptions_enabled = old_value_;
+        }
+    };
+
+    struct exception_base {
+        struct data_type {};
+        struct strong_type {
+            template <class T> void store(T const&) {}
+            template <class T> void test(T const&) const {}
+        };
+        data_type init() const { return data_type(); }
+        void check() const {}
+    };
+
+    template <class T, class P1, class P2, class T2>
+    inline void call_ignore_extra_parameters(void (T::*fn)() const, T2 const& obj,
+            P1&, P2&)
+    {
+        (obj.*fn)();
+    }
+
+    template <class T, class P1, class P2, class T2>
+    inline void call_ignore_extra_parameters(void (T::*fn)(P1&) const, T2 const& obj,
+            P1& p1, P2&)
+    {
+        (obj.*fn)(p1);
+    }
+
+    template <class T, class P1, class P2, class T2>
+    inline void call_ignore_extra_parameters(void (T::*fn)(P1&, P2&) const, T2 const& obj,
+            P1& p1, P2& p2)
+    {
+        (obj.*fn)(p1, p2);
+    }
+
+    template <class T>
+    T const& constant(T const& x) {
+        return x;
+    }
+
+    template <class Test>
+    class test_runner
+    {
+        Test const& test_;
+    public:
+        test_runner(Test const& t) : test_(t) {}
+        void operator()() const {
+            DISABLE_EXCEPTIONS;
+            BOOST_DEDUCED_TYPENAME Test::data_type x(test_.init());
+            BOOST_DEDUCED_TYPENAME Test::strong_type strong;
+            strong.store(x);
+            try {
+                ENABLE_EXCEPTIONS;
+                call_ignore_extra_parameters<Test, BOOST_DEDUCED_TYPENAME Test::data_type, BOOST_DEDUCED_TYPENAME Test::strong_type>(&Test::run, test_, x, strong);
+            }
+            catch(...) {
+                call_ignore_extra_parameters<Test, BOOST_DEDUCED_TYPENAME Test::data_type const, BOOST_DEDUCED_TYPENAME Test::strong_type const>(&Test::check, test_,
+                        constant(x), constant(strong));
+                throw;
+            }
+        }
+    };
+    
+    
+
+#if defined(BOOST_UNORDERED_USE_TEST)
+    template <class Test>
+    void exception_safety(Test const& f, char const* name) {
+        test_runner<Test> runner(f);
+        ::boost::itest::exception_safety(runner, name);
+    }
+#else
+    // Quick exception testing based on lightweight test
+
+    namespace lightweight {
+        static int iteration;
+        static int count;
+
+        struct test_exception {
+            char const* name;
+            test_exception(char const* n) : name(n) {}
+        };
+
+        struct test_failure {
+        };
+
+        void epoint(char const* name) {
+            ++count;
+            if(count == iteration) {
+                throw test_exception(name);
+            }
+        }
+
+        template <class Test>
+        void exception_safety(Test const& f, char const* name) {
+            test_runner<Test> runner(f);
+
+            iteration = 0;
+            bool success = false;
+            do {
+                ++iteration;
+                count = 0;
+
+                try {
+                    runner();
+                    success = true;
+                }
+                catch(test_failure) {
+                    break;
+                }
+                catch(...) {
+                }
+            } while(!success);
+        }
+    }
+#endif
+}
+
+#endif

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-13 09:44:59 EST (Sun, 13 Jan 2008)
@@ -6,243 +6,15 @@
 #if !defined(BOOST_UNORDERED_EXCEPTION_TEST_OBJECTS_HEADER)
 #define BOOST_UNORDERED_EXCEPTION_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/unit_test.hpp>
-#endif
+#include "../helpers/exception_test.hpp"
 
 #include <cstddef>
 #include <iostream>
 #include <boost/limits.hpp>
-#include <boost/preprocessor/seq/for_each_product.hpp>
-#include <boost/preprocessor/seq/elem.hpp>
-#include <boost/preprocessor/cat.hpp>
 #include "../helpers/fwd.hpp"
 #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)) \
-    UNORDERED_EXCEPTION_TEST_POSTFIX
-
-#define RUN_EXCEPTION_TESTS_OP(r, product) \
-    UNORDERED_EXCEPTION_TEST_CASE( \
-        BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product), \
-            BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(1, product)) \
-        ), \
-        BOOST_PP_SEQ_ELEM(0, product), \
-        BOOST_PP_SEQ_ELEM(1, product) \
-    )
-
-#define UNORDERED_SCOPE(scope_name) \
-    for(::test::scope_guard unordered_test_guard( \
-            BOOST_STRINGIZE(scope_name)); \
-        !unordered_test_guard.dismissed(); \
-        unordered_test_guard.dismiss())
-
-#define UNORDERED_EPOINT(name) \
-    if(::test::exceptions_enabled) { \
-        UNORDERED_EPOINT_IMPL(name); \
-    }
-
-#define ENABLE_EXCEPTIONS \
-    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(true)
-#define DISABLE_EXCEPTIONS \
-    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(false)
-
-namespace test {
-    static char const* scope = "";
-    bool exceptions_enabled = false;
-
-    class scope_guard {
-        scope_guard& operator=(scope_guard const&);
-        scope_guard(scope_guard const&);
-
-        char const* old_scope_;
-        char const* scope_;
-        bool dismissed_;
-    public:
-        scope_guard(char const* name)
-            : old_scope_(scope),
-            scope_(name),
-            dismissed_(false)
-        {
-            scope = scope_;
-        }
-
-        ~scope_guard() {
-            if(dismissed_) scope = old_scope_;
-        }
-
-        void dismiss() {
-            dismissed_ = true;
-        }
-
-        bool dismissed() const {
-            return dismissed_;
-        }
-    };
-
-    class exceptions_enable
-    {
-        exceptions_enable& operator=(exceptions_enable const&);
-        exceptions_enable(exceptions_enable const&);
-
-        bool old_value_;
-    public:
-        exceptions_enable(bool enable)
-            : old_value_(exceptions_enabled)
-        {
-            exceptions_enabled = enable;
-        }
-
-        ~exceptions_enable()
-        {
-            exceptions_enabled = old_value_;
-        }
-    };
-
-    struct exception_base {
-        struct data_type {};
-        struct strong_type {
-            template <class T> void store(T const&) {}
-            template <class T> void test(T const&) const {}
-        };
-        data_type init() const { return data_type(); }
-        void check() const {}
-    };
-
-    template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(void (T::*fn)() const, T2 const& obj,
-            P1&, P2&)
-    {
-        (obj.*fn)();
-    }
-
-    template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(void (T::*fn)(P1&) const, T2 const& obj,
-            P1& p1, P2&)
-    {
-        (obj.*fn)(p1);
-    }
-
-    template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(void (T::*fn)(P1&, P2&) const, T2 const& obj,
-            P1& p1, P2& p2)
-    {
-        (obj.*fn)(p1, p2);
-    }
-
-    template <class T>
-    T const& constant(T const& x) {
-        return x;
-    }
-
-    template <class Test>
-    class test_runner
-    {
-        Test const& test_;
-    public:
-        test_runner(Test const& t) : test_(t) {}
-        void operator()() const {
-            DISABLE_EXCEPTIONS;
-            BOOST_DEDUCED_TYPENAME Test::data_type x(test_.init());
-            BOOST_DEDUCED_TYPENAME Test::strong_type strong;
-            strong.store(x);
-            try {
-                ENABLE_EXCEPTIONS;
-                call_ignore_extra_parameters<Test, BOOST_DEDUCED_TYPENAME Test::data_type, BOOST_DEDUCED_TYPENAME Test::strong_type>(&Test::run, test_, x, strong);
-            }
-            catch(...) {
-                call_ignore_extra_parameters<Test, BOOST_DEDUCED_TYPENAME Test::data_type const, BOOST_DEDUCED_TYPENAME Test::strong_type const>(&Test::check, test_,
-                        constant(x), constant(strong));
-                throw;
-            }
-        }
-    };
-    
-    
-
-#if defined(BOOST_UNORDERED_USE_TEST)
-    template <class Test>
-    void exception_safety(Test const& f, char const* name) {
-        test_runner<Test> runner(f);
-        ::boost::itest::exception_safety(runner, name);
-    }
-#else
-
-    // Quick exception testing based on lightweight test
-
-    namespace lightweight {
-        static int iteration;
-        static int count;
-
-        struct test_exception {
-            char const* name;
-            test_exception(char const* n) : name(n) {}
-        };
-
-        struct test_failure {
-        };
-
-        void epoint(char const* name) {
-            ++count;
-            if(count == iteration) {
-                throw test_exception(name);
-            }
-        }
-
-        template <class Test>
-        void exception_safety(Test const& f, char const* name) {
-            test_runner<Test> runner(f);
-
-            iteration = 0;
-            bool success = false;
-            do {
-                ++iteration;
-                count = 0;
-
-                try {
-                    runner();
-                    success = true;
-                }
-                catch(test_failure) {
-                    break;
-                }
-                catch(...) {
-                }
-            } while(!success);
-        }
-    }
-#endif
-
-}
-
 namespace test
 {
 namespace exception