Subject: [Boost-commit] svn:boost r57975 - trunk/libs/unordered/test/unordered
From: daniel_james_at_[hidden]
Date: 2009-11-27 14:43:07
Author: danieljames
Date: 2009-11-27 14:43:06 EST (Fri, 27 Nov 2009)
New Revision: 57975
URL: http://svn.boost.org/trac/boost/changeset/57975
Log:
Better testing of incomplete types.
Text files modified:
trunk/libs/unordered/test/unordered/incomplete_test.cpp | 112 ++++++++++++++++++++++++++++++++++++---
1 files changed, 103 insertions(+), 9 deletions(-)
Modified: trunk/libs/unordered/test/unordered/incomplete_test.cpp
==============================================================================
--- trunk/libs/unordered/test/unordered/incomplete_test.cpp (original)
+++ trunk/libs/unordered/test/unordered/incomplete_test.cpp 2009-11-27 14:43:06 EST (Fri, 27 Nov 2009)
@@ -8,35 +8,129 @@
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
+namespace x
+{
+ struct D { boost::unordered_map<D, D> x; };
+}
+
namespace test
{
+ // Declare, but don't define some types.
+
struct value;
struct hash;
struct equals;
template <class T>
struct malloc_allocator;
+
+ // Declare some instances
typedef boost::unordered_map<value, value, hash, equals, malloc_allocator<std::pair<value const, value> > > map;
typedef boost::unordered_multimap<value, value, hash, equals, malloc_allocator<std::pair<value const, value> > > multimap;
typedef boost::unordered_set<value, hash, equals, malloc_allocator<value> > set;
typedef boost::unordered_multiset<value, hash, equals, malloc_allocator<value> > multiset;
- struct value {};
- struct hash { std::size_t operator()(value const&) const { return 0; } };
- struct equals { bool operator()(value const&, value const&) const { return true; } };
+ // Now define the types which are stored as members, as they are needed for
+ // declaring struct members.
+
+ struct hash {
+ template <typename T>
+ std::size_t operator()(T const&) const { return 0; }
+ };
+
+ struct equals {
+ template <typename T>
+ bool operator()(T const&, T const&) const { return true; }
+ };
+
}
#include "../helpers/allocator.hpp"
-int main() {
+namespace test
+{
+ // Declare some members of a structs.
+ //
+ // Incomplete hash, equals and allocator aren't here supported at the moment.
+
+ struct struct1 {
+ boost::unordered_map<struct1, struct1, hash, equals, malloc_allocator<std::pair<struct1 const, struct1> > > x;
+ };
+ struct struct2 {
+ boost::unordered_multimap<struct2, struct2, hash, equals, malloc_allocator<std::pair<struct2 const, struct2> > > x;
+ };
+ struct struct3 {
+ boost::unordered_set<struct3, hash, equals, malloc_allocator<struct3> > x;
+ };
+ struct struct4 {
+ boost::unordered_multiset<struct4, hash, equals, malloc_allocator<struct4> > x;
+ };
+
+ // Now define the value type.
+
+ struct value {};
+
+ // Create some instances.
+
test::map m1;
test::multimap m2;
test::set s1;
test::multiset s2;
+
+ test::struct1 c1;
+ test::struct2 c2;
+ test::struct3 c3;
+ test::struct4 c4;
+ // Now declare, but don't define, the operators required for comparing elements.
+
+ std::size_t hash_value(value const&);
+ bool operator==(value const&, value const&);
+
+ std::size_t hash_value(struct1 const&);
+ std::size_t hash_value(struct2 const&);
+ std::size_t hash_value(struct3 const&);
+ std::size_t hash_value(struct4 const&);
+
+ bool operator==(struct1 const&, struct1 const&);
+ bool operator==(struct2 const&, struct2 const&);
+ bool operator==(struct3 const&, struct3 const&);
+ bool operator==(struct4 const&, struct4 const&);
+
+ // And finally use these
+
+ void use_types()
+ {
+ test::value x;
+ m1[x] = x;
+ m2.insert(std::make_pair(x, x));
+ s1.insert(x);
+ s2.insert(x);
+
+ c1.x.insert(std::make_pair(c1, c1));
+ c2.x.insert(std::make_pair(c2, c2));
+ c3.x.insert(c3);
+ c4.x.insert(c4);
+ }
+
+ // And finally define the operators required for comparing elements.
+
+ std::size_t hash_value(value const&) { return 0; }
+ bool operator==(value const&, value const&) { return true; }
+
+ std::size_t hash_value(struct1 const&) { return 0; }
+ std::size_t hash_value(struct2 const&) { return 0; }
+ std::size_t hash_value(struct3 const&) { return 0; }
+ std::size_t hash_value(struct4 const&) { return 0; }
- test::value x;
- m1[x] = x;
- m2.insert(std::make_pair(x, x));
- s1.insert(x);
- s2.insert(x);
+ bool operator==(struct1 const&, struct1 const&) { return true; }
+ bool operator==(struct2 const&, struct2 const&) { return true; }
+ bool operator==(struct3 const&, struct3 const&) { return true; }
+ bool operator==(struct4 const&, struct4 const&) { return true; }
+}
+
+int main() {
+ // This could just be a compile test, but I like to be able to run these
+ // things. It's probably irrational, but I find it reassuring.
+
+ test::use_types();
}