2 files changed, 118 insertions, 0 deletions

diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
index d5d02077972..6a24c278e1a 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
@@ -19,6 +19,22 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
+struct NonAssignable {
+  NonAssignable& operator=(NonAssignable const&) = delete;
+  NonAssignable& operator=(NonAssignable&&) = delete;
+};
+struct CopyAssignable {
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable &&) = delete;
+};
+static_assert(std::is_copy_assignable<CopyAssignable>::value, "");
+struct MoveAssignable {
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
 int main()
 {
     {
@@ -51,4 +67,37 @@ int main()
         assert(std::get<1>(t) == 'a');
         assert(std::get<2>(t) == "some text");
     }
+    {
+        // test reference assignment.
+        using T = std::tuple<int&, int&&>;
+        int x = 42;
+        int y = 100;
+        int x2 = -1;
+        int y2 = 500;
+        T t(x, std::move(y));
+        T t2(x2, std::move(y2));
+        t = t2;
+        assert(std::get<0>(t) == x2);
+        assert(&std::get<0>(t) == &x);
+        assert(std::get<1>(t) == y2);
+        assert(&std::get<1>(t) == &y);
+    }
+    {
+        // test that the implicitly generated copy assignment operator
+        // is properly deleted
+        using T = std::tuple<std::unique_ptr<int>>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, NonAssignable>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, CopyAssignable>;
+        static_assert(std::is_copy_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, MoveAssignable>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+    }
 }
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
index fc5e41ad569..210f14be318 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
@@ -21,6 +21,33 @@
 
 #include "MoveOnly.h"
 
+struct NonAssignable {
+  NonAssignable& operator=(NonAssignable const&) = delete;
+  NonAssignable& operator=(NonAssignable&&) = delete;
+};
+struct CopyAssignable {
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable&&) = delete;
+};
+static_assert(std::is_copy_assignable<CopyAssignable>::value, "");
+struct MoveAssignable {
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
+
+struct CountAssign {
+  static int copied;
+  static int moved;
+  static void reset() { copied = moved = 0; }
+  CountAssign() = default;
+  CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
+  CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
+};
+int CountAssign::copied = 0;
+int CountAssign::moved = 0;
+
+
 int main()
 {
     {
@@ -53,4 +80,46 @@ int main()
         assert(std::get<1>(t) == 1);
         assert(std::get<2>(t) == 2);
     }
+    {
+        // test reference assignment.
+        using T = std::tuple<int&, int&&>;
+        int x = 42;
+        int y = 100;
+        int x2 = -1;
+        int y2 = 500;
+        T t(x, std::move(y));
+        T t2(x2, std::move(y2));
+        t = std::move(t2);
+        assert(std::get<0>(t) == x2);
+        assert(&std::get<0>(t) == &x);
+        assert(std::get<1>(t) == y2);
+        assert(&std::get<1>(t) == &y);
+    }
+    {
+        // test that the implicitly generated move assignment operator
+        // is properly deleted
+        using T = std::tuple<std::unique_ptr<int>>;
+        static_assert(std::is_move_assignable<T>::value, "");
+        static_assert(!std::is_copy_assignable<T>::value, "");
+
+    }
+    {
+        using T = std::tuple<int, NonAssignable>;
+        static_assert(!std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, MoveAssignable>;
+        static_assert(std::is_move_assignable<T>::value, "");
+    }
+    {
+        // The move should decay to a copy.
+        CountAssign::reset();
+        using T = std::tuple<CountAssign, CopyAssignable>;
+        static_assert(std::is_move_assignable<T>::value, "");
+        T t1;
+        T t2;
+        t1 = std::move(t2);
+        assert(CountAssign::copied == 1);
+        assert(CountAssign::moved == 0);
+    }
 }