Release 1.46.1

[SVN r69890]

test/objects/test.hpp

@@ -20,13 +20,11 @@ namespace test
     // Note that the default hash function will work for any equal_to (but not
     // very well).
     class object;
-    class implicitly_convertible;
     class hash;
     class less;
     class equal_to;
     template <class T> class allocator;
     object generate(object const*);
-    implicitly_convertible generate(implicitly_convertible const*);
 
     class object : globally_counted_object
     {
@@ -66,31 +64,6 @@ namespace test
         }
     };
 
-    class implicitly_convertible : globally_counted_object
-    {
-        int tag1_, tag2_;
-    public:
-
-        explicit implicitly_convertible(int t1 = 0, int t2 = 0)
-            : tag1_(t1), tag2_(t2)
-            {}
-
-        operator object() const
-        {
-            return object(tag1_, tag2_);
-        }
-
-        friend implicitly_convertible generate(implicitly_convertible const*) {
-            int* x = 0;
-            return implicitly_convertible(generate(x), generate(x));
-        }
-
-        friend std::ostream& operator<<(std::ostream& out, implicitly_convertible const& o)
-        {
-            return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
-        }
-    };
-
     class hash
     {
         int type_;
@@ -306,6 +279,44 @@ namespace test
     {
         return x == y;
     }
+
+#if BOOST_WORKAROUND(__GNUC__, < 3)
+    void swap(test::object& x, test::object& y) {
+        test::object tmp;
+        tmp = x;
+        x = y;
+        y = tmp;
+    }
+
+    void swap(test::hash& x, test::hash& y) {
+        test::hash tmp;
+        tmp = x;
+        x = y;
+        y = tmp;
+    }
+
+    void swap(test::less& x, test::less& y) {
+        test::less tmp;
+        tmp = x;
+        x = y;
+        y = tmp;
+    }
+
+    void swap(test::equal_to& x, test::equal_to& y) {
+        test::equal_to tmp;
+        tmp = x;
+        x = y;
+        y = tmp;
+    }
+
+    template <class T>
+    void swap(test::allocator<T>& x, test::allocator<T>& y) {
+        test::allocator<T> tmp;
+        tmp = x;
+        x = y;
+        y = tmp;
+    }
+#endif
 }
 
 #endif

test/unordered/insert_tests.cpp

@@ -372,10 +372,10 @@ void map_insert_range_test2(X*,
     std::cerr<<"map_insert_range_test2\n";
 
     typedef test::list<
-        std::pair<BOOST_DEDUCED_TYPENAME X::key_type const, test::implicitly_convertible>
+        std::pair<BOOST_DEDUCED_TYPENAME X::key_type const, int>
     > list;
     test::random_values<
-        boost::unordered_map<BOOST_DEDUCED_TYPENAME X::key_type, test::implicitly_convertible>
+        boost::unordered_map<BOOST_DEDUCED_TYPENAME X::key_type, int>
     > v(1000, generator);
     list l(v.begin(), v.end());
 

test/unordered/unnecessary_copy_tests.cpp

@@ -261,7 +261,7 @@ namespace unnecessary_copy_tests
         // copied.
         reset();
         x.emplace(source<std::pair<count_copies, count_copies> >());
-        COPY_COUNT(2); MOVE_COUNT_RANGE(0,2);
+        COPY_COUNT(2); MOVE_COUNT(0);
 
         // TODO: This doesn't work on older versions of gcc.
         //count_copies part;