Move test into test/std subdirectory.

llvm-svn: 224658

4 files changed, 0 insertions, 402 deletions

diff --git a/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp b/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
deleted file mode 100644
index 5e84ff8e882..00000000000
--- a/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <tuple>
-
-// template<class... Types>
-//     tuple<Types&&...> forward_as_tuple(Types&&... t);
-
-#include <tuple>
-#include <cassert>
-
-template <class Tuple>
-void
-test0(const Tuple& t)
-{
-    static_assert(std::tuple_size<Tuple>::value == 0, "");
-}
-
-template <class Tuple>
-void
-test1a(const Tuple& t)
-{
-    static_assert(std::tuple_size<Tuple>::value == 1, "");
-    static_assert(std::is_same<typename std::tuple_element<0, Tuple>::type, int&&>::value, "");
-    assert(std::get<0>(t) == 1);
-}
-
-template <class Tuple>
-void
-test1b(const Tuple& t)
-{
-    static_assert(std::tuple_size<Tuple>::value == 1, "");
-    static_assert(std::is_same<typename std::tuple_element<0, Tuple>::type, int&>::value, "");
-    assert(std::get<0>(t) == 2);
-}
-
-template <class Tuple>
-void
-test2a(const Tuple& t)
-{
-    static_assert(std::tuple_size<Tuple>::value == 2, "");
-    static_assert(std::is_same<typename std::tuple_element<0, Tuple>::type, double&>::value, "");
-    static_assert(std::is_same<typename std::tuple_element<1, Tuple>::type, char&>::value, "");
-    assert(std::get<0>(t) == 2.5);
-    assert(std::get<1>(t) == 'a');
-}
-
-#if _LIBCPP_STD_VER > 11
-template <class Tuple>
-constexpr int 
-test3(const Tuple& t)
-{
-    return std::tuple_size<Tuple>::value;
-}
-#endif
-
-int main()
-{
-    {
-        test0(std::forward_as_tuple());
-    }
-    {
-        test1a(std::forward_as_tuple(1));
-    }
-    {
-        int i = 2;
-        test1b(std::forward_as_tuple(i));
-    }
-    {
-        double i = 2.5;
-        char c = 'a';
-        test2a(std::forward_as_tuple(i, c));
-#if _LIBCPP_STD_VER > 11
-        static_assert ( test3 (std::forward_as_tuple(i, c)) == 2, "" );
-#endif
-    }
-}
diff --git a/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp b/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
deleted file mode 100644
index 5b33d1a23f8..00000000000
--- a/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <tuple>
-
-// template <class... Types> class tuple;
-
-// template<class... Types>
-//   tuple<VTypes...> make_tuple(Types&&... t);
-
-#include <tuple>
-#include <functional>
-#include <cassert>
-
-int main()
-{
-    {
-        int i = 0;
-        float j = 0;
-        std::tuple<int, int&, float&> t = std::make_tuple(1, std::ref(i),
-                                                          std::ref(j));
-        assert(std::get<0>(t) == 1);
-        assert(std::get<1>(t) == 0);
-        assert(std::get<2>(t) == 0);
-        i = 2;
-        j = 3.5;
-        assert(std::get<0>(t) == 1);
-        assert(std::get<1>(t) == 2);
-        assert(std::get<2>(t) == 3.5);
-        std::get<1>(t) = 0;
-        std::get<2>(t) = 0;
-        assert(i == 0);
-        assert(j == 0);
-    }
-#if _LIBCPP_STD_VER > 11 
-    {
-        constexpr auto t1 = std::make_tuple(0, 1, 3.14);
-        constexpr int i1 = std::get<1>(t1);
-        constexpr double d1 = std::get<2>(t1);
-        static_assert (i1 == 1, "" );
-        static_assert (d1 == 3.14, "" );
-    }
-#endif
-}
diff --git a/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp b/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
deleted file mode 100644
index e6ebf958e6f..00000000000
--- a/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <tuple>
-
-// template <class... Types> class tuple;
-
-// template<class... Types>
-//   tuple<Types&...> tie(Types&... t);
-
-#include <tuple>
-#include <string>
-#include <cassert>
-
-int main()
-{
-    {
-        int i = 0;
-        std::string s;
-        std::tie(i, std::ignore, s) = std::make_tuple(42, 3.14, "C++");
-        assert(i == 42);
-        assert(s == "C++");
-    }
-#if _LIBCPP_STD_VER > 11
-    {
-        static constexpr int i = 42;
-        static constexpr double f = 1.1;
-        constexpr std::tuple<const int &, const double &> t = std::tie(i, f);
-        static_assert ( std::get<0>(t) == 42, "" );
-        static_assert ( std::get<1>(t) == 1.1, "" );
-    }
-#endif
-}
diff --git a/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp b/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
deleted file mode 100644
index 3fca5738929..00000000000
--- a/libcxx/test/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
+++ /dev/null
@@ -1,230 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <tuple>
-
-// template <class... Types> class tuple;
-
-// template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
-
-#include <tuple>
-#include <utility>
-#include <array>
-#include <string>
-#include <cassert>
-
-#include "../MoveOnly.h"
-
-int main()
-{
-    {
-        std::tuple<> t = std::tuple_cat();
-    }
-    {
-        std::tuple<> t1;
-        std::tuple<> t2 = std::tuple_cat(t1);
-    }
-    {
-        std::tuple<> t = std::tuple_cat(std::tuple<>());
-    }
-    {
-        std::tuple<> t = std::tuple_cat(std::array<int, 0>());
-    }
-    {
-        std::tuple<int> t1(1);
-        std::tuple<int> t = std::tuple_cat(t1);
-        assert(std::get<0>(t) == 1);
-    }
-
-#if _LIBCPP_STD_VER > 11 
-    {
-        constexpr std::tuple<> t = std::tuple_cat();
-    }
-    {
-        constexpr std::tuple<> t1;
-        constexpr std::tuple<> t2 = std::tuple_cat(t1);
-    }
-    {
-        constexpr std::tuple<> t = std::tuple_cat(std::tuple<>());
-    }
-    {
-        constexpr std::tuple<> t = std::tuple_cat(std::array<int, 0>());
-    }
-    {
-        constexpr std::tuple<int> t1(1);
-        constexpr std::tuple<int> t = std::tuple_cat(t1);
-        static_assert(std::get<0>(t) == 1, "");
-    }
-    {
-        constexpr std::tuple<int> t1(1);
-        constexpr std::tuple<int, int> t = std::tuple_cat(t1, t1);
-        static_assert(std::get<0>(t) == 1, "");
-        static_assert(std::get<1>(t) == 1, "");
-    }
-#endif
-    {
-        std::tuple<int, MoveOnly> t =
-                                std::tuple_cat(std::tuple<int, MoveOnly>(1, 2));
-        assert(std::get<0>(t) == 1);
-        assert(std::get<1>(t) == 2);
-    }
-    {
-        std::tuple<int, int, int> t = std::tuple_cat(std::array<int, 3>());
-        assert(std::get<0>(t) == 0);
-        assert(std::get<1>(t) == 0);
-        assert(std::get<2>(t) == 0);
-    }
-    {
-        std::tuple<int, MoveOnly> t = std::tuple_cat(std::pair<int, MoveOnly>(2, 1));
-        assert(std::get<0>(t) == 2);
-        assert(std::get<1>(t) == 1);
-    }
-
-    {
-        std::tuple<> t1;
-        std::tuple<> t2;
-        std::tuple<> t3 = std::tuple_cat(t1, t2);
-    }
-    {
-        std::tuple<> t1;
-        std::tuple<int> t2(2);
-        std::tuple<int> t3 = std::tuple_cat(t1, t2);
-        assert(std::get<0>(t3) == 2);
-    }
-    {
-        std::tuple<> t1;
-        std::tuple<int> t2(2);
-        std::tuple<int> t3 = std::tuple_cat(t2, t1);
-        assert(std::get<0>(t3) == 2);
-    }
-    {
-        std::tuple<int*> t1;
-        std::tuple<int> t2(2);
-        std::tuple<int*, int> t3 = std::tuple_cat(t1, t2);
-        assert(std::get<0>(t3) == nullptr);
-        assert(std::get<1>(t3) == 2);
-    }
-    {
-        std::tuple<int*> t1;
-        std::tuple<int> t2(2);
-        std::tuple<int, int*> t3 = std::tuple_cat(t2, t1);
-        assert(std::get<0>(t3) == 2);
-        assert(std::get<1>(t3) == nullptr);
-    }
-    {
-        std::tuple<int*> t1;
-        std::tuple<int, double> t2(2, 3.5);
-        std::tuple<int*, int, double> t3 = std::tuple_cat(t1, t2);
-        assert(std::get<0>(t3) == nullptr);
-        assert(std::get<1>(t3) == 2);
-        assert(std::get<2>(t3) == 3.5);
-    }
-    {
-        std::tuple<int*> t1;
-        std::tuple<int, double> t2(2, 3.5);
-        std::tuple<int, double, int*> t3 = std::tuple_cat(t2, t1);
-        assert(std::get<0>(t3) == 2);
-        assert(std::get<1>(t3) == 3.5);
-        assert(std::get<2>(t3) == nullptr);
-    }
-    {
-        std::tuple<int*, MoveOnly> t1(nullptr, 1);
-        std::tuple<int, double> t2(2, 3.5);
-        std::tuple<int*, MoveOnly, int, double> t3 =
-                                              std::tuple_cat(std::move(t1), t2);
-        assert(std::get<0>(t3) == nullptr);
-        assert(std::get<1>(t3) == 1);
-        assert(std::get<2>(t3) == 2);
-        assert(std::get<3>(t3) == 3.5);
-    }
-    {
-        std::tuple<int*, MoveOnly> t1(nullptr, 1);
-        std::tuple<int, double> t2(2, 3.5);
-        std::tuple<int, double, int*, MoveOnly> t3 =
-                                              std::tuple_cat(t2, std::move(t1));
-        assert(std::get<0>(t3) == 2);
-        assert(std::get<1>(t3) == 3.5);
-        assert(std::get<2>(t3) == nullptr);
-        assert(std::get<3>(t3) == 1);
-    }
-    {
-        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
-        std::tuple<int*, MoveOnly> t2(nullptr, 4);
-        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
-                                   std::tuple_cat(std::move(t1), std::move(t2));
-        assert(std::get<0>(t3) == 1);
-        assert(std::get<1>(t3) == 2);
-        assert(std::get<2>(t3) == nullptr);
-        assert(std::get<3>(t3) == 4);
-    }
-
-    {
-        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
-        std::tuple<int*, MoveOnly> t2(nullptr, 4);
-        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
-                                   std::tuple_cat(std::tuple<>(),
-                                                  std::move(t1),
-                                                  std::move(t2));
-        assert(std::get<0>(t3) == 1);
-        assert(std::get<1>(t3) == 2);
-        assert(std::get<2>(t3) == nullptr);
-        assert(std::get<3>(t3) == 4);
-    }
-    {
-        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
-        std::tuple<int*, MoveOnly> t2(nullptr, 4);
-        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
-                                   std::tuple_cat(std::move(t1),
-                                                  std::tuple<>(),
-                                                  std::move(t2));
-        assert(std::get<0>(t3) == 1);
-        assert(std::get<1>(t3) == 2);
-        assert(std::get<2>(t3) == nullptr);
-        assert(std::get<3>(t3) == 4);
-    }
-    {
-        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
-        std::tuple<int*, MoveOnly> t2(nullptr, 4);
-        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
-                                   std::tuple_cat(std::move(t1),
-                                                  std::move(t2),
-                                                  std::tuple<>());
-        assert(std::get<0>(t3) == 1);
-        assert(std::get<1>(t3) == 2);
-        assert(std::get<2>(t3) == nullptr);
-        assert(std::get<3>(t3) == 4);
-    }
-    {
-        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
-        std::tuple<int*, MoveOnly> t2(nullptr, 4);
-        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly, int> t3 =
-                                   std::tuple_cat(std::move(t1),
-                                                  std::move(t2),
-                                                  std::tuple<int>(5));
-        assert(std::get<0>(t3) == 1);
-        assert(std::get<1>(t3) == 2);
-        assert(std::get<2>(t3) == nullptr);
-        assert(std::get<3>(t3) == 4);
-        assert(std::get<4>(t3) == 5);
-    }
-    {
-        // See bug #19616.
-        auto t1 = std::tuple_cat(
-            std::make_tuple(std::make_tuple(1)),
-            std::make_tuple()
-        );
-        assert(t1 == std::make_tuple(std::make_tuple(1)));
-
-        auto t2 = std::tuple_cat(
-            std::make_tuple(std::make_tuple(1)),
-            std::make_tuple(std::make_tuple(2))
-        );
-        assert(t2 == std::make_tuple(std::make_tuple(1), std::make_tuple(2)));
-    }
-}