Add is_swappable/is_nothrow_swappable traits

llvm-svn: 267079

1 files changed, 75 insertions, 25 deletions

diff --git a/libcxx/test/std/utilities/utility/utility.swap/swap.pass.cpp b/libcxx/test/std/utilities/utility/utility.swap/swap.pass.cpp
index 8606611f660..c9c9f3b5276 100644
--- a/libcxx/test/std/utilities/utility/utility.swap/swap.pass.cpp
+++ b/libcxx/test/std/utilities/utility/utility.swap/swap.pass.cpp
@@ -16,38 +16,88 @@
 
 #include <utility>
 #include <cassert>
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #include <memory>
-#endif
 
-void
-test()
-{
-    int i = 1;
-    int j = 2;
-    std::swap(i, j);
-    assert(i == 2);
-    assert(j == 1);
-}
+#include "test_macros.h"
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
+struct CopyOnly {
+    CopyOnly() {}
+    CopyOnly(CopyOnly const&) noexcept {}
+    CopyOnly& operator=(CopyOnly const&) { return *this; }
+};
 
-void
-test1()
-{
-    std::unique_ptr<int> i(new int(1));
-    std::unique_ptr<int> j(new int(2));
-    std::swap(i, j);
-    assert(*i == 2);
-    assert(*j == 1);
-}
+struct MoveOnly {
+    MoveOnly() {}
+    MoveOnly(MoveOnly&&) {}
+    MoveOnly& operator=(MoveOnly&&) noexcept { return *this; }
+};
+
+struct NoexceptMoveOnly {
+    NoexceptMoveOnly() {}
+    NoexceptMoveOnly(NoexceptMoveOnly&&) noexcept {}
+    NoexceptMoveOnly& operator=(NoexceptMoveOnly&&) noexcept { return *this; }
+};
+
+struct NotMoveConstructible {
+    NotMoveConstructible& operator=(NotMoveConstructible&&) { return *this; }
+private:
+    NotMoveConstructible(NotMoveConstructible&&);
+};
+
+struct NotMoveAssignable {
+    NotMoveAssignable(NotMoveAssignable&&);
+private:
+    NotMoveAssignable& operator=(NotMoveAssignable&&);
+};
+
+template <class Tp>
+auto can_swap_test(int) -> decltype(std::swap(std::declval<Tp>(), std::declval<Tp>()));
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+template <class Tp>
+auto can_swap_test(...) -> std::false_type;
+
+template <class Tp>
+constexpr bool can_swap() {
+    return std::is_same<decltype(can_swap_test<Tp>(0)), void>::value;
+}
+#endif
 
 int main()
 {
-    test();
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    test1();
+
+    {
+        int i = 1;
+        int j = 2;
+        std::swap(i, j);
+        assert(i == 2);
+        assert(j == 1);
+    }
+#if TEST_STD_VER >= 11
+    {
+
+        std::unique_ptr<int> i(new int(1));
+        std::unique_ptr<int> j(new int(2));
+        std::swap(i, j);
+        assert(*i == 2);
+        assert(*j == 1);
+
+    }
+    {
+        // test that the swap
+        static_assert(can_swap<CopyOnly&>(), "");
+        static_assert(can_swap<MoveOnly&>(), "");
+        static_assert(can_swap<NoexceptMoveOnly&>(), "");
+
+        static_assert(!can_swap<NotMoveConstructible&>(), "");
+        static_assert(!can_swap<NotMoveAssignable&>(), "");
+
+        CopyOnly c;
+        MoveOnly m;
+        NoexceptMoveOnly nm;
+        static_assert(!noexcept(std::swap(c, c)), "");
+        static_assert(!noexcept(std::swap(m, m)), "");
+        static_assert(noexcept(std::swap(nm, nm)), "");
+    }
 #endif
 }