Boost logo

Boost-Commit :

From: daniel_james_at_[hidden]
Date: 2008-01-12 09:43:41


Author: danieljames
Date: 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
New Revision: 42698
URL: http://svn.boost.org/trac/boost/changeset/42698

Log:
Merge the latest unordered changes. These are concerned with getting the tests
working on more compilers. The biggest change is that the exception tests have
been changed to use a very simple exception testing mechanism on top of
lightweight_test. This was because Boost.Test exception testing isn't working
on several platforms. I'm trying to set this up so that I can use Boost.Test on
compilers which it completely supports, and lightweight test on others.
Boost.Test tests more than my simple exception testing code ever will so it's
worth using where I can.

Added:
   trunk/libs/unordered/test/helpers/test.hpp
      - copied unchanged from r42697, /branches/unordered/trunk/libs/unordered/test/helpers/test.hpp
Properties modified:
   trunk/ (props changed)
Text files modified:
   trunk/libs/unordered/test/exception/Jamfile.v2 | 3
   trunk/libs/unordered/test/exception/assign_exception_tests.cpp | 4 -
   trunk/libs/unordered/test/exception/constructor_exception_tests.cpp | 4 -
   trunk/libs/unordered/test/exception/copy_exception_tests.cpp | 4 -
   trunk/libs/unordered/test/exception/erase_exception_tests.cpp | 6 -
   trunk/libs/unordered/test/exception/insert_exception_tests.cpp | 26 ++++-----
   trunk/libs/unordered/test/exception/rehash_exception_tests.cpp | 4 -
   trunk/libs/unordered/test/exception/swap_exception_tests.cpp | 8 --
   trunk/libs/unordered/test/objects/exception.hpp | 108 ++++++++++++++++++++++++++++++++++++---
   trunk/libs/unordered/test/objects/memory.hpp | 33 +++++++-----
   10 files changed, 134 insertions(+), 66 deletions(-)

Modified: trunk/libs/unordered/test/exception/Jamfile.v2
==============================================================================
--- trunk/libs/unordered/test/exception/Jamfile.v2 (original)
+++ trunk/libs/unordered/test/exception/Jamfile.v2 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -5,7 +5,8 @@
 
 import testing ;
 
-alias framework : /boost/test//boost_unit_test_framework ;
+#alias framework : /boost/test//boost_unit_test_framework ;
+alias framework : ;
 
 project unordered-test/exception-tests
     : requirements

Modified: trunk/libs/unordered/test/exception/assign_exception_tests.cpp
==============================================================================
--- trunk/libs/unordered/test/exception/assign_exception_tests.cpp (original)
+++ trunk/libs/unordered/test/exception/assign_exception_tests.cpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -4,10 +4,6 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "./containers.hpp"
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-#include <boost/test/exception_safety.hpp>
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 

Modified: trunk/libs/unordered/test/exception/constructor_exception_tests.cpp
==============================================================================
--- trunk/libs/unordered/test/exception/constructor_exception_tests.cpp (original)
+++ trunk/libs/unordered/test/exception/constructor_exception_tests.cpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -4,10 +4,6 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "./containers.hpp"
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-#include <boost/test/exception_safety.hpp>
 #include "../helpers/random_values.hpp"
 #include "../helpers/input_iterator.hpp"
 

Modified: trunk/libs/unordered/test/exception/copy_exception_tests.cpp
==============================================================================
--- trunk/libs/unordered/test/exception/copy_exception_tests.cpp (original)
+++ trunk/libs/unordered/test/exception/copy_exception_tests.cpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -4,10 +4,6 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "./containers.hpp"
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-#include <boost/test/exception_safety.hpp>
 #include "../helpers/random_values.hpp"
 
 test::seed_t seed(73041);

Modified: trunk/libs/unordered/test/exception/erase_exception_tests.cpp
==============================================================================
--- trunk/libs/unordered/test/exception/erase_exception_tests.cpp (original)
+++ trunk/libs/unordered/test/exception/erase_exception_tests.cpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -4,10 +4,6 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "./containers.hpp"
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-#include <boost/test/exception_safety.hpp>
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 #include "../helpers/helpers.hpp"
@@ -29,7 +25,7 @@
     void check(T const& x) const {
         std::string scope(test::scope);
 
- HASH_CHECK(scope.find("hash::") != std::string::npos ||
+ UNORDERED_CHECK(scope.find("hash::") != std::string::npos ||
                 scope.find("equal_to::") != std::string::npos ||
                 scope == "operator==(object, object)");
 

Modified: trunk/libs/unordered/test/exception/insert_exception_tests.cpp
==============================================================================
--- trunk/libs/unordered/test/exception/insert_exception_tests.cpp (original)
+++ trunk/libs/unordered/test/exception/insert_exception_tests.cpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -4,16 +4,12 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "./containers.hpp"
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-#include <boost/test/exception_safety.hpp>
 #include <string>
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 #include "../helpers/strong.hpp"
 #include "../helpers/input_iterator.hpp"
-
+#include <boost/utility.hpp>
 #include <cmath>
 
 test::seed_t seed(747373);
@@ -105,17 +101,18 @@
     insert_test_rehash1() : insert_test_base<T>(1000) {}
 
     T init() const {
+ using namespace std;
         typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
 
         T x;
         x.max_load_factor(0.25);
         size_type bucket_count = x.bucket_count();
         size_type initial_elements = static_cast<size_type>(
- std::ceil(bucket_count * x.max_load_factor()) - 1);
- BOOST_REQUIRE(initial_elements < this->values.size());
+ ceil(bucket_count * (double) x.max_load_factor()) - 1);
+ UNORDERED_REQUIRE(initial_elements < this->values.size());
         x.insert(this->values.begin(),
                 boost::next(this->values.begin(), initial_elements));
- BOOST_REQUIRE(bucket_count == x.bucket_count());
+ UNORDERED_REQUIRE(bucket_count == x.bucket_count());
         return x;
     }
 
@@ -134,7 +131,7 @@
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
- BOOST_REQUIRE(x.bucket_count() != bucket_count);
+ UNORDERED_REQUIRE(x.bucket_count() != bucket_count);
     }
 };
 
@@ -157,7 +154,7 @@
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
- BOOST_REQUIRE(x.bucket_count() != bucket_count);
+ UNORDERED_REQUIRE(x.bucket_count() != bucket_count);
     }
 };
 
@@ -169,6 +166,7 @@
     insert_test_rehash3() : insert_test_base<T>(1000) {}
 
     T init() const {
+ using namespace std;
         typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
 
         T x;
@@ -176,14 +174,14 @@
 
         original_bucket_count = x.bucket_count();
         rehash_bucket_count = static_cast<size_type>(
- std::ceil(original_bucket_count * x.max_load_factor())) - 1;
+ ceil(original_bucket_count * (double) x.max_load_factor())) - 1;
 
         size_type initial_elements = rehash_bucket_count - 5;
 
- BOOST_REQUIRE(initial_elements < this->values.size());
+ UNORDERED_REQUIRE(initial_elements < this->values.size());
         x.insert(this->values.begin(),
                 boost::next(this->values.begin(), initial_elements));
- BOOST_REQUIRE(original_bucket_count == x.bucket_count());
+ UNORDERED_REQUIRE(original_bucket_count == x.bucket_count());
         return x;
     }
 
@@ -195,7 +193,7 @@
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
- BOOST_REQUIRE(x.bucket_count() != bucket_count);
+ UNORDERED_REQUIRE(x.bucket_count() != bucket_count);
     }
 
     void check(T const& x) const {

Modified: trunk/libs/unordered/test/exception/rehash_exception_tests.cpp
==============================================================================
--- trunk/libs/unordered/test/exception/rehash_exception_tests.cpp (original)
+++ trunk/libs/unordered/test/exception/rehash_exception_tests.cpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -4,10 +4,6 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "./containers.hpp"
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-#include <boost/test/exception_safety.hpp>
 #include <string>
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"

Modified: trunk/libs/unordered/test/exception/swap_exception_tests.cpp
==============================================================================
--- trunk/libs/unordered/test/exception/swap_exception_tests.cpp (original)
+++ trunk/libs/unordered/test/exception/swap_exception_tests.cpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -4,10 +4,6 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "./containers.hpp"
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-#include <boost/test/exception_safety.hpp>
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 
@@ -26,7 +22,7 @@
         std::string scope(test::scope);
 
 #if BOOST_UNORDERED_SWAP_METHOD != 2
- HASH_CHECK(
+ UNORDERED_CHECK(
                 scope == "hash::operator(hash)" ||
                 scope == "hash::operator=(hash)" ||
                 scope == "equal_to::operator(equal_to)" ||
@@ -77,7 +73,7 @@
         std::string scope(test::scope);
 
 #if BOOST_UNORDERED_SWAP_METHOD != 2
- HASH_CHECK(
+ UNORDERED_CHECK(
                 scope == "hash::operator(hash)" ||
                 scope == "hash::operator=(hash)" ||
                 scope == "equal_to::operator(equal_to)" ||

Modified: trunk/libs/unordered/test/objects/exception.hpp
==============================================================================
--- trunk/libs/unordered/test/objects/exception.hpp (original)
+++ trunk/libs/unordered/test/objects/exception.hpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -6,24 +6,32 @@
 #if !defined(BOOST_UNORDERED_TEST_OBJECTS_HEADER)
 #define BOOST_UNORDERED_TEST_OBJECTS_HEADER
 
+#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>
+#endif
+
 #include <cstddef>
+#include <iostream>
 #include <boost/limits.hpp>
-#include <boost/test/test_tools.hpp>
-#include <boost/test/exception_safety.hpp>
 #include <boost/preprocessor/seq/for_each_product.hpp>
 #include <boost/preprocessor/seq/elem.hpp>
 #include <boost/preprocessor/cat.hpp>
-#include <iostream>
 #include "../helpers/fwd.hpp"
 #include "../helpers/allocator.hpp"
-#include "memory.hpp"
-#include <map>
+#include "./memory.hpp"
 
 #define RUN_EXCEPTION_TESTS(test_seq, param_seq) \
- BOOST_PP_SEQ_FOR_EACH_PRODUCT(RUN_EXCEPTION_TESTS_OP, (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) \
- RUN_EXCEPTION_TESTS_OP2( \
+ UNORDERED_EXCEPTION_TEST_CASE( \
         BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product), \
             BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(1, product)) \
         ), \
@@ -31,12 +39,25 @@
         BOOST_PP_SEQ_ELEM(1, product) \
     )
 
-#define RUN_EXCEPTION_TESTS_OP2(name, test_func, type) \
+
+#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) \
     for(::test::scope_guard unordered_test_guard( \
@@ -44,10 +65,17 @@
         !unordered_test_guard.dismissed(); \
         unordered_test_guard.dismiss())
 
+#if defined(BOOST_UNORDERED_USE_TEST)
 #define EPOINT(name) \
     if(::test::exceptions_enabled) { \
         BOOST_ITEST_EPOINT(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)
@@ -155,21 +183,71 @@
             strong.store(x);
             try {
                 ENABLE_EXCEPTIONS;
- call_ignore_extra_parameters(&Test::run, test_, x, strong);
+ 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::check, test_,
+ 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
@@ -550,5 +628,15 @@
 }
 }
 
+// Workaround for ADL deficient compilers
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace test
+{
+ test::exception::object generate(test::exception::object const* x) {
+ return test::exception::generate(x);
+ }
+}
+#endif
+
 #endif
 

Modified: trunk/libs/unordered/test/objects/memory.hpp
==============================================================================
--- trunk/libs/unordered/test/objects/memory.hpp (original)
+++ trunk/libs/unordered/test/objects/memory.hpp 2008-01-12 09:43:40 EST (Sat, 12 Jan 2008)
@@ -6,7 +6,11 @@
 #if !defined(BOOST_UNORDERED_TEST_MEMORY_HEADER)
 #define BOOST_UNORDERED_TEST_MEMORY_HEADER
 
-#define HASH_CHECK(test) if(!(test)) BOOST_ERROR(BOOST_STRINGIZE(test))
+#include <memory>
+#include <map>
+#include <boost/mpl/apply.hpp>
+#include <boost/assert.hpp>
+#include "../helpers/test.hpp"
 
 namespace test
 {
@@ -58,8 +62,7 @@
         template <class AllocatorHolder = default_allocator_holder>
         struct memory_tracker {
             typedef std::map<memory_area, memory_track, memory_area_compare,
- BOOST_DEDUCED_TYPENAME AllocatorHolder::
- template apply<std::pair<memory_area const, memory_track> >::type
+ BOOST_DEDUCED_TYPENAME boost::mpl::apply1<AllocatorHolder, std::pair<memory_area const, memory_track> >::type
> allocated_memory_type;
 
             allocated_memory_type allocated_memory;
@@ -84,7 +87,7 @@
 
             void allocator_unref()
             {
- HASH_CHECK(count_allocators > 0);
+ UNORDERED_CHECK(count_allocators > 0);
                 if(count_allocators > 0) {
                     --count_allocators;
                     if(count_allocators == 0) {
@@ -97,9 +100,9 @@
                         count_constructions = 0;
                         allocated_memory.clear();
 
- HASH_CHECK(no_allocations_left);
- HASH_CHECK(no_constructions_left);
- HASH_CHECK(allocated_memory_empty);
+ UNORDERED_CHECK(no_allocations_left);
+ UNORDERED_CHECK(no_constructions_left);
+ UNORDERED_CHECK(allocated_memory_empty);
                     }
                 }
             }
@@ -111,8 +114,10 @@
                 }
                 else {
                     ++count_allocations;
- allocated_memory[memory_area(ptr, (char*) ptr + n * size)] =
- memory_track(tag);
+ allocated_memory.insert(
+ std::pair<memory_area const, memory_track>(
+ memory_area(ptr, (char*) ptr + n * size),
+ memory_track(tag)));
                 }
             }
 
@@ -123,12 +128,12 @@
                 if(pos == allocated_memory.end()) {
                     BOOST_ERROR("Deallocating unknown pointer.");
                 } else {
- HASH_CHECK(pos->first.start == ptr);
- HASH_CHECK(pos->first.end == (char*) ptr + n * size);
- HASH_CHECK(pos->second.tag_ == tag);
+ UNORDERED_CHECK(pos->first.start == ptr);
+ UNORDERED_CHECK(pos->first.end == (char*) ptr + n * size);
+ UNORDERED_CHECK(pos->second.tag_ == tag);
                     allocated_memory.erase(pos);
                 }
- HASH_CHECK(count_allocations > 0);
+ UNORDERED_CHECK(count_allocations > 0);
                 if(count_allocations > 0) --count_allocations;
             }
 
@@ -139,7 +144,7 @@
 
             void track_destroy(void* ptr, std::size_t /*size*/, int tag)
             {
- HASH_CHECK(count_constructions > 0);
+ UNORDERED_CHECK(count_constructions > 0);
                 if(count_constructions > 0) --count_constructions;
             }
         };


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk