[Boost-commit] svn:boost r44734 - branches/unordered/trunk/libs/unordered/test/unordered

From: daniel_james_at_[hidden]
Date: 2008-04-23 02:55:55

Author: danieljames
Date: 2008-04-23 02:55:55 EDT (Wed, 23 Apr 2008)
New Revision: 44734
URL: http://svn.boost.org/trac/boost/changeset/44734

Log:
More unnecessary copy tests - showing some weakness in the emplace implementation.

Text files modified: 
   branches/unordered/trunk/libs/unordered/test/unordered/unnecessary_copy_tests.cpp |   209 ++++++++++++++++++++++++++++++++++++--- 
   1 files changed, 191 insertions(+), 18 deletions(-)

Modified: branches/unordered/trunk/libs/unordered/test/unordered/unnecessary_copy_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/unnecessary_copy_tests.cpp	(original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/unnecessary_copy_tests.cpp	2008-04-23 02:55:55 EDT (Wed, 23 Apr 2008)
@@ -11,15 +11,34 @@
 {
     struct count_copies
     {
-        static int count;
-        count_copies() { ++count; }
-        count_copies(count_copies const&) { ++count; }
+        static int copies;
+        static int moves;
+        count_copies() : tag_(0) { ++copies; }
+        explicit count_copies(int tag) : tag_(tag) { ++copies; }
+        count_copies(count_copies const&, count_copies const& x) : tag_(x.tag_) { ++copies; }
+        count_copies(count_copies const& x) : tag_(x.tag_) { ++copies; }
+#if defined(BOOST_HAS_RVALUE_REFS)
+        count_copies(count_copies&& x) : tag_(x.tag_) {
+            x.tag_ = -1; ++moves;
+        }
+#endif
+       int tag_;
     private:
        count_copies& operator=(count_copies const&);
     };
 
-    bool operator==(count_copies const&, count_copies const&) {
-        return true;
+    bool operator==(count_copies const& x, count_copies const& y) {
+        return x.tag_ == y.tag_;
+    }
+
+    template <class T>
+    T source() {
+        return T();
+    }
+
+    void reset() {
+        count_copies::copies = 0;
+        count_copies::moves = 0;
     }
 }
 
@@ -29,29 +48,36 @@
 namespace unnecessary_copy_tests
 #endif
 {
-    std::size_t hash_value(unnecessary_copy_tests::count_copies const&) {
-        return 0;
+    std::size_t hash_value(unnecessary_copy_tests::count_copies const& x) {
+        return x.tag_;
     }
 }
 
+#define COPY_COUNT(n) \
+    if(count_copies::copies != n) { \
+        BOOST_ERROR("Wrong number of copies."); \
+        std::cerr<<"Number of copies: "<<count_copies::copies<<std::endl; \
+    }
+#define MOVE_COUNT(n) \
+    if(count_copies::moves != n) { \
+        BOOST_ERROR("Wrong number of moves."); \
+        std::cerr<<"Number of moves: "<<count_copies::moves<<std::endl; \
+    }
+
 namespace unnecessary_copy_tests
 {
-    int count_copies::count;
+    int count_copies::copies;
+    int count_copies::moves;
 
     template <class T>
-    void unnecessary_copy_test(T*)
+    void unnecessary_copy_insert_test(T*)
     {
-        count_copies::count = 0;
+        reset();
         T x;
         BOOST_DEDUCED_TYPENAME T::value_type a;
-        BOOST_CHECK(count_copies::count == 1);
-        if(count_copies::count != 1)
-            std::cerr<<count_copies::count<<" copies.\n";
-
+        COPY_COUNT(1);
         x.insert(a);
-        BOOST_CHECK(count_copies::count == 2);
-        if(count_copies::count != 2)
-            std::cerr<<count_copies::count<<" copies.\n";
+        COPY_COUNT(2);
     }
 
     boost::unordered_set<count_copies>* set;
@@ -59,7 +85,154 @@
     boost::unordered_map<int, count_copies>* map;
     boost::unordered_multimap<int, count_copies>* multimap;
 
-    UNORDERED_TEST(unnecessary_copy_test, ((set)(multiset)(map)(multimap)))
+    UNORDERED_TEST(unnecessary_copy_insert_test,
+            ((set)(multiset)(map)(multimap)))
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+    template <class T>
+    void unnecessary_copy_emplace_test(T*)
+    {
+        reset();
+        T x;
+        BOOST_DEDUCED_TYPENAME T::value_type a;
+        COPY_COUNT(1);
+        x.emplace(a);
+        COPY_COUNT(2);
+    }
+
+    template <class T>
+    void unnecessary_copy_emplace_rvalue_test(T*)
+    {
+        reset();
+        T x;
+        x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
+        COPY_COUNT(1);
+    }
+
+    template <class T>
+    void unnecessary_copy_emplace_move_test(T*)
+    {
+        reset();
+        T x;
+        BOOST_DEDUCED_TYPENAME T::value_type a;
+        COPY_COUNT(1); MOVE_COUNT(0);
+        x.emplace(std::move(a));
+        COPY_COUNT(1); MOVE_COUNT(1);
+    }
+
+    UNORDERED_TEST(unnecessary_copy_emplace_test,
+            ((set)(multiset)(map)(multimap)))
+    UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
+            ((set)(multiset)(map)(multimap)))
+    UNORDERED_TEST(unnecessary_copy_emplace_move_test,
+            ((set)(multiset)(map)(multimap)))
+
+    UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
+    {
+        reset();
+        boost::unordered_set<count_copies> x;
+        count_copies a;
+        x.insert(a);
+        COPY_COUNT(2); MOVE_COUNT(0);
+
+        //
+        // 0 arguments
+        // 
+
+        // The container will have to create a copy in order to compare with
+        // the existing element.
+        reset();
+        x.emplace();
+        COPY_COUNT(1); MOVE_COUNT(0);
+
+        //
+        // 1 arguments
+        // 
+
+        // Emplace should be able to tell that there already is an element
+        // without creating a new one.
+        reset();
+        x.insert(a);
+        COPY_COUNT(0); MOVE_COUNT(0);
+
+        // A new object is created by source, but it shouldn't be moved or
+        // copied.
+        reset();
+        x.insert(source<count_copies>());
+        COPY_COUNT(1); MOVE_COUNT(0);
+
+        // No move should take place.
+        reset();
+        x.emplace(std::move(a));
+        COPY_COUNT(0); MOVE_COUNT(0);
+
+        // Just in case a did get moved...
+        count_copies b;
+
+        // The container will have to create a copy in order to compare with
+        // the existing element.
+        reset();
+        x.emplace(b.tag_);
+        COPY_COUNT(1); MOVE_COUNT(0);
+
+        //
+        // 2 arguments
+        //
+
+        // The container will have to create b copy in order to compare with
+        // the existing element.
+
+        reset();
+        x.emplace(b, b);
+        COPY_COUNT(1); MOVE_COUNT(0);
+    }
+
+    UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
+    {
+        reset();
+        boost::unordered_map<count_copies, count_copies> x;
+        // TODO: Run tests for pairs without const etc.
+        std::pair<count_copies const, count_copies> a;
+        x.emplace(a);
+        COPY_COUNT(4); MOVE_COUNT(0);
+
+        //
+        // 0 arguments
+        //
+
+        // COPY_COUNT(1) would be okay here.
+        reset();
+        x.emplace();
+        COPY_COUNT(2); MOVE_COUNT(0);
+
+        //
+        // 1 argument
+        //
+
+        reset();
+        x.emplace(a);
+        COPY_COUNT(0); MOVE_COUNT(0);
+
+        // A new object is created by source, but it shouldn't be moved or
+        // copied.
+        reset();
+        x.emplace(source<std::pair<count_copies, count_copies> >());
+        COPY_COUNT(2); MOVE_COUNT(0);
+
+        // No move should take place.
+        reset();
+        x.emplace(std::move(a));
+        COPY_COUNT(0); MOVE_COUNT(0);
+
+        //
+        // 2 arguments
+        //
+
+        reset();
+        x.emplace(source<count_copies>(), source<count_copies>());
+        COPY_COUNT(2); MOVE_COUNT(0);
+    }
+#endif
 }
 
 RUN_TESTS()