Fix for PR18735 - self-assignment for map/multimap gives incorrect results in C++03

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@201021 91177308-0d34-0410-b5e6-96231b3b80d8

include/map

@@ -884,10 +884,12 @@ public:
 #if __cplusplus >= 201103L
             __tree_ = __m.__tree_;
 #else
-            __tree_.clear();
+            if (this != &__m) {
-            __tree_.value_comp() = __m.__tree_.value_comp();
+                __tree_.clear();
-            __tree_.__copy_assign_alloc(__m.__tree_);
+                __tree_.value_comp() = __m.__tree_.value_comp();
-            insert(__m.begin(), __m.end());
+                __tree_.__copy_assign_alloc(__m.__tree_);
+                insert(__m.begin(), __m.end());
+            }
 #endif
             return *this;
         }
@@ -1616,10 +1618,12 @@ public:
 #if __cplusplus >= 201103L
             __tree_ = __m.__tree_;
 #else
-            __tree_.clear();
+            if (this != &__m) {
-            __tree_.value_comp() = __m.__tree_.value_comp();
+                __tree_.clear();
-            __tree_.__copy_assign_alloc(__m.__tree_);
+                __tree_.value_comp() = __m.__tree_.value_comp();
-            insert(__m.begin(), __m.end());
+                __tree_.__copy_assign_alloc(__m.__tree_);
+                insert(__m.begin(), __m.end());
+            }
 #endif
             return *this;
         }

include/unordered_map

@@ -831,12 +831,14 @@ public:
 #if __cplusplus >= 201103L
         __table_ = __u.__table_;
 #else
-        __table_.clear();
+        if (this != &__u) {
-        __table_.hash_function() = __u.__table_.hash_function();
+            __table_.clear();
-        __table_.key_eq() = __u.__table_.key_eq();
+            __table_.hash_function() = __u.__table_.hash_function();
-        __table_.max_load_factor() = __u.__table_.max_load_factor();
+            __table_.key_eq() = __u.__table_.key_eq();
-        __table_.__copy_assign_alloc(__u.__table_);
+            __table_.max_load_factor() = __u.__table_.max_load_factor();
-        insert(__u.begin(), __u.end());
+            __table_.__copy_assign_alloc(__u.__table_);
+            insert(__u.begin(), __u.end());
+        }
 #endif
         return *this;
     }
@@ -1567,12 +1569,14 @@ public:
 #if __cplusplus >= 201103L
         __table_ = __u.__table_;
 #else
-        __table_.clear();
+        if (this != &__u) {
-        __table_.hash_function() = __u.__table_.hash_function();
+            __table_.clear();
-        __table_.key_eq() = __u.__table_.key_eq();
+            __table_.hash_function() = __u.__table_.hash_function();
-        __table_.max_load_factor() = __u.__table_.max_load_factor();
+            __table_.key_eq() = __u.__table_.key_eq();
-        __table_.__copy_assign_alloc(__u.__table_);
+            __table_.max_load_factor() = __u.__table_.max_load_factor();
-        insert(__u.begin(), __u.end());
+            __table_.__copy_assign_alloc(__u.__table_);
+            insert(__u.begin(), __u.end());
+        }
 #endif
         return *this;
     }

test/containers/associative/map/map.cons/copy_assign.pass.cpp

@@ -57,6 +57,21 @@ int main()
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
+    {
+        typedef std::pair<const int, double> V;
+        const V ar[] =
+        {
+            V(1, 1),
+            V(2, 1),
+            V(3, 1),
+        };
+        std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
+        std::map<int, double> *p = &m;
+        m = *p;
+
+        assert(m.size() == 3);
+        assert(std::equal(m.begin(), m.end(), ar));
+    }
     {
         typedef std::pair<const int, double> V;
         V ar[] =

test/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp

@@ -48,6 +48,26 @@ int main()
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
     }
+    {
+        typedef std::pair<const int, double> V;
+        const V ar[] =
+        {
+            V(1, 1),
+            V(1, 1.5),
+            V(1, 2),
+            V(2, 1),
+            V(2, 1.5),
+            V(2, 2),
+            V(3, 1),
+            V(3, 1.5),
+            V(3, 2),
+        };
+        std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
+        std::multimap<int, double> *p = &m;
+        m = *p;
+        assert(m.size() == sizeof(ar)/sizeof(ar[0]));
+        assert(std::equal(m.begin(), m.end(), ar));
+    }
     {
         typedef std::pair<const int, double> V;
         V ar[] =

test/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp

@@ -68,6 +68,26 @@ int main()
         assert(*next(mo.begin(), 7) == 3);
         assert(*next(mo.begin(), 8) == 3);
     }
+    {
+        typedef int V;
+        const V ar[] =
+        {
+            1,
+            1,
+            1,
+            2,
+            2,
+            2,
+            3,
+            3,
+            3
+        };
+        std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
+        std::multiset<int> *p = &m;
+        m = *p;
+        assert(m.size() == 9);
+        assert(std::equal(m.begin(), m.end(), ar));
+    }
     {
         typedef int V;
         V ar[] =

test/containers/associative/set/set.cons/copy_assign.pass.cpp

@@ -56,6 +56,21 @@ int main()
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
+    {
+        typedef int V;
+        const V ar[] =
+        {
+            1,
+            2,
+            3
+        };
+        std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
+        std::set<int> *p = &m;
+        m = *p;
+
+        assert(m.size() == 3);
+        assert(std::equal(m.begin(), m.end(), ar));
+    }
     {
         typedef int V;
         V ar[] =

test/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp

@@ -72,6 +72,24 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+    {
+        typedef std::unordered_map<int, std::string> C;
+        typedef std::pair<const int, std::string> P;
+        const P a[] =
+        {
+            P(1, "one"),
+            P(2, "two"),
+            P(3, "three"),
+            P(4, "four"),
+            P(1, "four"),
+            P(2, "four"),
+        };
+        C c(a, a + sizeof(a)/sizeof(a[0]));
+        C *p = &c;
+		c = *p;
+        assert(c.size() == 4);
+        assert(std::is_permutation(c.begin(), c.end(), a));
+    }
     {
         typedef other_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,

test/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp

@@ -86,6 +86,24 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+    {
+        typedef std::unordered_multimap<int, std::string> C;
+        typedef std::pair<const int, std::string> P;
+        const P a[] =
+        {
+            P(1, "one"),
+            P(2, "two"),
+            P(3, "three"),
+            P(4, "four"),
+            P(1, "four"),
+            P(2, "four"),
+        };
+        C c(a, a+sizeof(a)/sizeof(a[0]));
+        C *p = &c;
+        c = *p;
+        assert(c.size() == 6);
+        assert(std::is_permutation(c.begin(), c.end(), a));
+    }
     {
         typedef other_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,

test/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp

@@ -79,6 +79,25 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+    {
+        typedef std::unordered_multiset<int> C;
+        typedef int P;
+        P a[] =
+        {
+            P(1),
+            P(2),
+            P(3),
+            P(4),
+            P(1),
+            P(2)
+        };
+        C c(a, a + sizeof(a)/sizeof(a[0]));
+        C *p = &c;
+        c = *p;
+
+        assert(c.size() == 6);
+        assert(std::is_permutation(c.begin(), c.end(), a));
+    }
     {
         typedef other_allocator<int> A;
         typedef std::unordered_multiset<int,

test/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp

@@ -71,6 +71,24 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+    {
+        typedef std::unordered_set<int> C;
+        typedef int P;
+        P a[] =
+        {
+            P(1),
+            P(2),
+            P(3),
+            P(4),
+            P(1),
+            P(2)
+        };
+        C c(a, a + sizeof(a)/sizeof(a[0]));
+        C *p = &c;
+        c = *p;
+        assert(c.size() == 4);
+        assert(std::is_permutation(c.begin(), c.end(), a));
+    }
     {
         typedef other_allocator<int> A;
         typedef std::unordered_set<int,