diff options
author | Ben Cheng <bccheng@google.com> | 2014-03-25 22:37:19 -0700 |
---|---|---|
committer | Ben Cheng <bccheng@google.com> | 2014-03-25 22:37:19 -0700 |
commit | 1bc5aee63eb72b341f506ad058502cd0361f0d10 (patch) | |
tree | c607e8252f3405424ff15bc2d00aa38dadbb2518 /gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions | |
parent | 283a0bf58fcf333c58a2a92c3ebbc41fb9eb1fdb (diff) | |
download | toolchain_gcc-1bc5aee63eb72b341f506ad058502cd0361f0d10.tar.gz toolchain_gcc-1bc5aee63eb72b341f506ad058502cd0361f0d10.tar.bz2 toolchain_gcc-1bc5aee63eb72b341f506ad058502cd0361f0d10.zip |
Initial checkin of GCC 4.9.0 from trunk (r208799).
Change-Id: I48a3c08bb98542aa215912a75f03c0890e497dba
Diffstat (limited to 'gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions')
8 files changed, 581 insertions, 0 deletions
diff --git a/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/23978.cc b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/23978.cc new file mode 100644 index 000000000..1c34d857b --- /dev/null +++ b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/23978.cc @@ -0,0 +1,45 @@ +// { dg-options "-std=gnu++0x" } +// +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// Tuple + +#include <tuple> +#include <utility> +#include <testsuite_hooks.h> + +using namespace std; + +// libstdc++/23978 +void test01() +{ + bool test __attribute__((unused)) = true; + + pair<int, int> p(1, 2); + int x = 0; + int y = 0; + tie(x, y) = p; + VERIFY( x == 1 && y == 2 ); +} + +int +main() +{ + test01(); + return 0; +} diff --git a/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/48476.cc b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/48476.cc new file mode 100644 index 000000000..72a80d161 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/48476.cc @@ -0,0 +1,85 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <tuple> +#include <type_traits> +#include <testsuite_hooks.h> + +template<typename T> + typename std::decay<T>::type copy(T&& x) + { return std::forward<T>(x); } + +template<typename... Args1, typename... Args2> + void + check_tuple_cat(std::tuple<Args1...> t1, std::tuple<Args2...> t2) + { + bool test __attribute__((unused)) = true; + + typedef std::tuple<Args1..., Args2...> concatenated; + + auto cat1 = std::tuple_cat( t1, t2 ); + auto cat2 = std::tuple_cat(copy(t1), t2 ); + auto cat3 = std::tuple_cat( t1, copy(t2)); + auto cat4 = std::tuple_cat(copy(t1), copy(t2)); + + static_assert( std::is_same<decltype(cat1), concatenated>::value, "" ); + static_assert( std::is_same<decltype(cat2), concatenated>::value, "" ); + static_assert( std::is_same<decltype(cat3), concatenated>::value, "" ); + static_assert( std::is_same<decltype(cat4), concatenated>::value, "" ); + + VERIFY( cat1 == cat2 ); + VERIFY( cat1 == cat3 ); + VERIFY( cat1 == cat4 ); + } + +// libstdc++/48476 +void test01() +{ + int i = 0; + std::tuple<> t0; + std::tuple<int&> t1(i); + std::tuple<int&, int> t2(i, 0); + std::tuple<int const&, int, double> t3(i, 0, 0); + + check_tuple_cat(t0, t0); + check_tuple_cat(t0, t1); + check_tuple_cat(t0, t2); + check_tuple_cat(t0, t3); + + check_tuple_cat(t1, t0); + check_tuple_cat(t1, t1); + check_tuple_cat(t1, t2); + check_tuple_cat(t1, t3); + + check_tuple_cat(t2, t0); + check_tuple_cat(t2, t1); + check_tuple_cat(t2, t2); + check_tuple_cat(t2, t3); + + check_tuple_cat(t3, t0); + check_tuple_cat(t3, t1); + check_tuple_cat(t3, t2); + check_tuple_cat(t3, t3); +} + +int main() +{ + test01(); + return 0; +} diff --git a/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/constexpr.cc b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/constexpr.cc new file mode 100644 index 000000000..47f3e3f6f --- /dev/null +++ b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/constexpr.cc @@ -0,0 +1,131 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + + +// NOTE: This makes use of the fact that we know how moveable +// is implemented on pair, and also vector. If the implementation +// changes this test may begin to fail. + +#include <tuple> + +bool test __attribute__((unused)) = true; + + +// make_tuple +void +test_make_tuple() +{ + { + typedef std::tuple<int, float> tuple_type; + constexpr tuple_type p1 __attribute__((unused)) + = std::make_tuple(22, 22.222); + } + + { + typedef std::tuple<int, float, int> tuple_type; + constexpr tuple_type p1 __attribute__((unused)) + = std::make_tuple(22, 22.222, 77799); + } +} + +#if 0 +// forward_as_tuple +void +test_forward_as_tuple() +{ + { + typedef std::tuple<int, float> tuple_type; + constexpr tuple_type p1 __attribute__((unused)) + = std::forward_as_tuple(22, 22.222); + } + + { + typedef std::tuple<int, float, int> tuple_type; + constexpr tuple_type p1 __attribute__((unused)) + = std::forward_as_tuple(22, 22.222, 77799); + } +} +#endif + +#if 0 +// tie +void +test_tie() +{ + { + int i(22); + float f(22.222); + typedef std::tuple<int, float> tuple_type; + constexpr tuple_type p1 __attribute__((unused)) + = std::tie(i, f); + } + + { + int i(22); + float f(22.222); + int ii(77799); + + typedef std::tuple<int, float, int> tuple_type; + constexpr tuple_type p1 __attribute__((unused)) + = std::tie(i, f, ii); + } +} +#endif + +// get +void +test_get() +{ + { + typedef std::tuple<int, float> tuple_type; + constexpr tuple_type t1 { 55, 77.77 }; + constexpr auto var __attribute__((unused)) + = std::get<1>(t1); + } + + { + typedef std::tuple<int, float, int> tuple_type; + constexpr tuple_type t1 { 55, 77.77, 99 }; + constexpr auto var __attribute__((unused)) + = std::get<2>(t1); + } +} + +// tuple_cat +void +test_tuple_cat() +{ + typedef std::tuple<int, float> tuple_type1; + typedef std::tuple<int, int, float> tuple_type2; + + constexpr tuple_type1 t1 { 55, 77.77 }; + constexpr tuple_type2 t2 { 55, 99, 77.77 }; + constexpr auto cat1 __attribute__((unused)) = std::tuple_cat(t1, t2); +} + +int +main() +{ + test_make_tuple(); + test_get(); + test_tuple_cat(); + + return 0; +} diff --git a/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/forward_as_tuple.cc b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/forward_as_tuple.cc new file mode 100644 index 000000000..c096f95c0 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/forward_as_tuple.cc @@ -0,0 +1,72 @@ +// { dg-options "-std=gnu++0x" } + +// 2010-04-30 Paolo Carlini <paolo.carlini@oracle.com> +// +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// Tuple + +#include <tuple> +#include <type_traits> +#include <testsuite_hooks.h> + +void +test01() +{ + bool test __attribute__((unused)) = true; + + std::forward_as_tuple(); + + VERIFY( std::get<0>(std::forward_as_tuple(-1)) == -1 ); + VERIFY( (std::is_same<decltype(std::forward_as_tuple(-1)), + std::tuple<int&&>>::value) ); + + const int i1 = 1; + const int i2 = 2; + const double d1 = 4.0; + auto t1 = std::forward_as_tuple(i1, i2, d1); + VERIFY( (std::is_same<decltype(t1), std::tuple<const int&, + const int&, const double&>>::value) ); + VERIFY( std::get<0>(t1) == i1 ); + VERIFY( std::get<1>(t1) == i2 ); + VERIFY( std::get<2>(t1) == d1 ); + + typedef const int a_type1[3]; + a_type1 a1 = { -1, 1, 2 }; + auto t2 = std::forward_as_tuple(a1); + VERIFY( (std::is_same<decltype(t2), std::tuple<a_type1&>>::value) ); + VERIFY( std::get<0>(t2)[0] == a1[0] ); + VERIFY( std::get<0>(t2)[1] == a1[1] ); + VERIFY( std::get<0>(t2)[2] == a1[2] ); + + typedef int a_type2[2]; + a_type2 a2 = { 2, -2 }; + volatile int i4 = 1; + auto t3 = std::forward_as_tuple(a2, i4); + VERIFY( (std::is_same<decltype(t3), std::tuple<a_type2&, + volatile int&>>::value) ); + VERIFY( std::get<0>(t3)[0] == a2[0] ); + VERIFY( std::get<0>(t3)[1] == a2[1] ); + VERIFY( std::get<1>(t3) == i4 ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/make_tuple.cc b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/make_tuple.cc new file mode 100644 index 000000000..17d748e8c --- /dev/null +++ b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/make_tuple.cc @@ -0,0 +1,37 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// Tuple + +#include <tuple> +#include <functional> +#include <testsuite_hooks.h> + +using namespace std; + +int +main() +{ + bool test __attribute__((unused)) = true; + + int i=0; + make_tuple(1,2,4.0); + make_tuple(ref(i)) = tuple<int>(1); + VERIFY(i == 1); +} diff --git a/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tie.cc b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tie.cc new file mode 100644 index 000000000..7263d875d --- /dev/null +++ b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tie.cc @@ -0,0 +1,42 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// Tuple + +#include <tuple> +#include <testsuite_hooks.h> + +using namespace std; + +int +main() +{ + bool test __attribute__((unused)) = true; + + int x1 = 0; + int x2 = 0; + int y1 = 0; + int y2 = 0; + tuple<int,int> ta(1,1); + tuple<const int&,const int&> tc(x1,x2); + tie(y1,y2)=ta; + VERIFY(y1 == 1 && y2 == 1); + tie(y1,y2)=tc; + VERIFY(y1 == 0 && y2 == 0); +} diff --git a/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tie2.cc b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tie2.cc new file mode 100644 index 000000000..cc1af3a61 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tie2.cc @@ -0,0 +1,38 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// Tuple + +#include <tuple> +#include <string> +#include <testsuite_hooks.h> + +int +main() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + int i; + string s; + + tie(i, ignore, s) = make_tuple(42, 3.14, "C++"); + VERIFY( i == 42 ); + VERIFY( s == "C++" ); +} diff --git a/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tuple_cat.cc b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tuple_cat.cc new file mode 100644 index 000000000..1217fe575 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/testsuite/20_util/tuple/creation_functions/tuple_cat.cc @@ -0,0 +1,131 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// Tuple + +#include <tuple> +#include <array> + +static_assert(std::is_same<decltype(std::tuple_cat()), + std::tuple<>>::value, "Error"); +static_assert(std::is_same<decltype(std::tuple_cat + (std::declval<std::tuple<>>())), + std::tuple<>>::value, "Error"); +static_assert(std::is_same<decltype(std::tuple_cat + (std::declval<std::tuple<>&>())), + std::tuple<>>::value, "Error"); +static_assert(std::is_same<decltype(std::tuple_cat + (std::declval<const std::tuple<>>())), + std::tuple<>>::value, "Error"); +static_assert(std::is_same<decltype(std::tuple_cat + (std::declval<const std::tuple<>&>())), + std::tuple<>>::value, "Error"); +static_assert(std::is_same<decltype(std::tuple_cat + (std::declval<std::pair<int, bool>>())), + std::tuple<int, bool>>::value, "Error"); +static_assert(std::is_same<decltype(std::tuple_cat + (std::declval<std::pair<int, bool>&>())), + std::tuple<int, bool>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat(std::declval<const std::pair<int, bool>>())), + std::tuple<int, bool>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat(std::declval<const std::pair<int, bool>&>())), + std::tuple<int, bool>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat(std::declval<std::array<int, 3>>())), + std::tuple<int, int, int>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat(std::declval<std::array<int, 3>&>())), + std::tuple<int, int, int>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat(std::declval<const std::array<int, 3>>())), + std::tuple<int, int, int>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat(std::declval<const std::array<int, 3>&>())), + std::tuple<int, int, int>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat + (std::declval<std::tuple<>>(), std::declval<std::tuple<>>())), + std::tuple<>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat + (std::declval<std::tuple<>>(), std::declval<std::tuple<>>(), + std::declval<std::tuple<>>())), std::tuple<>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat + (std::declval<std::tuple<>>(), + std::declval<std::array<char, 0>>(), + std::declval<std::array<int, 0>>(), + std::declval<std::tuple<>>())), std::tuple<>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat + (std::declval<std::tuple<int>>(), + std::declval<std::tuple<double>>())), + std::tuple<int, double>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat + (std::declval<std::tuple<int>>(), + std::declval<std::tuple<double>>(), + std::declval<std::tuple<const long&>>())), + std::tuple<int, double, const long&>>::value, "Error"); +static_assert(std::is_same<decltype + (std::tuple_cat + (std::declval<std::array<wchar_t, 3>&>(), + std::declval<std::tuple<double>>(), + std::declval<std::tuple<>>(), + std::declval<std::tuple<unsigned&>>(), + std::declval<std::pair<bool, std::nullptr_t>>())), + std::tuple<wchar_t, wchar_t, wchar_t, + double, unsigned&, bool, std::nullptr_t> + >::value, "Error"); + +int main() +{ + std::tuple_cat(); + std::tuple_cat(std::tuple<>{ }); + std::tuple_cat(std::tuple<>{ }, std::tuple<>{ }); + std::array<int, 3> a3; + std::tuple_cat(a3); + std::pair<double, bool> pdb; + std::tuple<unsigned, float, std::nullptr_t, void*> t; + int i{ }; + double d{ }; + int* pi{ }; + std::tuple<int&, double&, int*&> to{i, d, pi}; + std::tuple_cat(pdb); + std::tuple_cat(to); + std::tuple_cat(to, to); + std::tuple_cat(a3, pdb); + std::tuple_cat(a3, pdb, t); + std::tuple_cat(a3, pdb, t, a3); + std::tuple_cat(a3, pdb, t, a3, pdb, t); + + static_assert(std::is_same<decltype + (std::tuple_cat(a3, pdb, t, a3, pdb, t)), + std::tuple<int, int, int, double, bool, + unsigned, float, std::nullptr_t, void*, + int, int, int, double, bool, unsigned, + float, std::nullptr_t, void*> + >::value, "Error"); + + std::tuple_cat(std::tuple<int, char, void*>{}, to, a3, + std::tuple<>{}, std::pair<float, + std::nullptr_t>{}, pdb, to); +} |