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_;
}