generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move test into test/std subdirectory.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@224658 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2014-12-20 01:40:03 +00:00
parent 669a8a5a19
commit a90c6dd460
4817 changed files with 13 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// 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 U1, class U2>
// tuple& operator=(const pair<U1, U2>& u);
#include <tuple>
#include <utility>
#include <cassert>
int main()
{
{
typedef std::pair<double, char> T0;
typedef std::tuple<int, short> T1;
T0 t0(2.5, 'a');
T1 t1;
t1 = t0;
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == short('a'));
}
}

75
test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp Normal file
View File

@@ -0,0 +1,75 @@
//===----------------------------------------------------------------------===//
//
// 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... UTypes>
// tuple& operator=(const tuple<UTypes...>& u);
#include <tuple>
#include <string>
#include <cassert>
struct B
{
int id_;
explicit B(int i = 0) : id_(i) {}
};
struct D
: B
{
explicit D(int i = 0) : B(i) {}
};
int main()
{
{
typedef std::tuple<double> T0;
typedef std::tuple<int> T1;
T0 t0(2.5);
T1 t1;
t1 = t0;
assert(std::get<0>(t1) == 2);
}
{
typedef std::tuple<double, char> T0;
typedef std::tuple<int, int> T1;
T0 t0(2.5, 'a');
T1 t1;
t1 = t0;
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == int('a'));
}
{
typedef std::tuple<double, char, D> T0;
typedef std::tuple<int, int, B> T1;
T0 t0(2.5, 'a', D(3));
T1 t1;
t1 = t0;
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == int('a'));
assert(std::get<2>(t1).id_ == 3);
}
{
D d(3);
D d2(2);
typedef std::tuple<double, char, D&> T0;
typedef std::tuple<int, int, B&> T1;
T0 t0(2.5, 'a', d2);
T1 t1(1.5, 'b', d);
t1 = t0;
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == int('a'));
assert(std::get<2>(t1).id_ == 2);
}
}

88
test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp Normal file
View File

@@ -0,0 +1,88 @@
//===----------------------------------------------------------------------===//
//
// 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... UTypes>
// tuple& operator=(tuple<UTypes...>&& u);
#include <tuple>
#include <string>
#include <memory>
#include <cassert>
struct B
{
int id_;
explicit B(int i= 0) : id_(i) {}
virtual ~B() {}
};
struct D
: B
{
explicit D(int i) : B(i) {}
};
int main()
{
{
typedef std::tuple<double> T0;
typedef std::tuple<int> T1;
T0 t0(2.5);
T1 t1;
t1 = std::move(t0);
assert(std::get<0>(t1) == 2);
}
{
typedef std::tuple<double, char> T0;
typedef std::tuple<int, int> T1;
T0 t0(2.5, 'a');
T1 t1;
t1 = std::move(t0);
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == int('a'));
}
{
typedef std::tuple<double, char, D> T0;
typedef std::tuple<int, int, B> T1;
T0 t0(2.5, 'a', D(3));
T1 t1;
t1 = std::move(t0);
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == int('a'));
assert(std::get<2>(t1).id_ == 3);
}
{
D d(3);
D d2(2);
typedef std::tuple<double, char, D&> T0;
typedef std::tuple<int, int, B&> T1;
T0 t0(2.5, 'a', d2);
T1 t1(1.5, 'b', d);
t1 = std::move(t0);
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == int('a'));
assert(std::get<2>(t1).id_ == 2);
}
{
typedef std::tuple<double, char, std::unique_ptr<D>> T0;
typedef std::tuple<int, int, std::unique_ptr<B>> T1;
T0 t0(2.5, 'a', std::unique_ptr<D>(new D(3)));
T1 t1;
t1 = std::move(t0);
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == int('a'));
assert(std::get<2>(t1)->id_ == 3);
}
}

29
test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp Normal file
View File

@@ -0,0 +1,29 @@
//===----------------------------------------------------------------------===//
//
// 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;
// tuple& operator=(const tuple& u);
#include <tuple>
#include <cassert>
#include "../MoveOnly.h"
int main()
{
{
typedef std::tuple<MoveOnly> T;
T t0(MoveOnly(2));
T t;
t = t0;
}
}

52
test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp Normal file
View File

@@ -0,0 +1,52 @@
//===----------------------------------------------------------------------===//
//
// 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;
// tuple& operator=(const tuple& u);
#include <tuple>
#include <string>
#include <cassert>
int main()
{
{
typedef std::tuple<> T;
T t0;
T t;
t = t0;
}
{
typedef std::tuple<int> T;
T t0(2);
T t;
t = t0;
assert(std::get<0>(t) == 2);
}
{
typedef std::tuple<int, char> T;
T t0(2, 'a');
T t;
t = t0;
assert(std::get<0>(t) == 2);
assert(std::get<1>(t) == 'a');
}
{
typedef std::tuple<int, char, std::string> T;
const T t0(2, 'a', "some text");
T t;
t = t0;
assert(std::get<0>(t) == 2);
assert(std::get<1>(t) == 'a');
assert(std::get<2>(t) == "some text");
}
}

53
test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp Normal file
View File

@@ -0,0 +1,53 @@
//===----------------------------------------------------------------------===//
//
// 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;
// tuple& operator=(tuple&& u);
#include <tuple>
#include <cassert>
#include "../MoveOnly.h"
int main()
{
{
typedef std::tuple<> T;
T t0;
T t;
t = std::move(t0);
}
{
typedef std::tuple<MoveOnly> T;
T t0(MoveOnly(0));
T t;
t = std::move(t0);
assert(std::get<0>(t) == 0);
}
{
typedef std::tuple<MoveOnly, MoveOnly> T;
T t0(MoveOnly(0), MoveOnly(1));
T t;
t = std::move(t0);
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
}
{
typedef std::tuple<MoveOnly, MoveOnly, MoveOnly> T;
T t0(MoveOnly(0), MoveOnly(1), MoveOnly(2));
T t;
t = std::move(t0);
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
assert(std::get<2>(t) == 2);
}
}

48
test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp Normal file
View File

@@ -0,0 +1,48 @@
//===----------------------------------------------------------------------===//
//
// 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 U1, class U2>
// tuple& operator=(pair<U1, U2>&& u);
#include <tuple>
#include <utility>
#include <memory>
#include <cassert>
struct B
{
int id_;
explicit B(int i = 0) : id_(i) {}
virtual ~B() {}
};
struct D
: B
{
explicit D(int i) : B(i) {}
};
int main()
{
{
typedef std::pair<double, std::unique_ptr<D>> T0;
typedef std::tuple<int, std::unique_ptr<B>> T1;
T0 t0(2.5, std::unique_ptr<D>(new D(3)));
T1 t1;
t1 = std::move(t0);
assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1)->id_ == 3);
}
}

32
test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// 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 Tuple, __tuple_assignable<Tuple, tuple> >
// tuple & operator=(Tuple &&);
// This test checks that we do not evaluate __make_tuple_types
// on the array when it doesn't match the size of the tuple.
#include <array>
#include <tuple>
// Use 1256 to try and blow the template instantiation depth for all compilers.
typedef std::array<char, 1256> array_t;
typedef std::tuple<array_t> tuple_t;
int main()
{
array_t arr;
tuple_t tup;
tup = arr;
}