URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/tags/gnu-dev/fsf-gcc-snapshot-1-mar-12/or1k-gcc/libstdc++-v3/testsuite/20_util/tuple
- from Rev 742 to Rev 783
- ↔ Reverse comparison
Rev 742 → Rev 783
/48476.cc
0,0 → 1,51
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2011 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 <memory> |
#include <testsuite_hooks.h> |
|
template<typename T> |
typename std::decay<T>::type copy(T&& x) |
{ return std::forward<T>(x); } |
|
// libstdc++/48476 |
void test01() |
{ |
bool test __attribute__((unused)) = true; |
|
std::shared_ptr<int> p(new int()), q, r; |
|
std::tuple<std::shared_ptr<int>&, int> t0(p, 23), t1(q, 0); |
t1 = copy(t0); // shall be equivalent to |
// q = p; std::get<1>(t1) = std::get<1>(t0); |
VERIFY( q == p ); |
|
std::tuple<std::shared_ptr<int>&, char> t2(r, 0); |
t2 = copy(t1); // shall be equivalent to |
// r = q; std::get<1>(t2) = std::get<1>(t1); |
VERIFY( r == q ); |
} |
|
int main() |
{ |
test01(); |
return 0; |
} |
/requirements/dr801.cc
0,0 → 1,52
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2010 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> |
|
// DR 801, pair and tuple vs. "passed in registers" |
void test_trivial() |
{ |
// PODType, TType, NType, SLType, LType, NLType, LTypeDerived |
typedef std::tuple<int, int> tuple_type; |
// static_assert(std::is_literal_type<tuple_type>::value, "! literal"); |
static_assert(std::has_trivial_copy_constructor<tuple_type>::value, |
"! triv copy"); |
static_assert(std::has_trivial_destructor<tuple_type>::value, |
"! triv destructor"); |
// static_assert(std::is_standard_layout<tuple_type>::value, |
// "! standard layout"); |
|
// Negative |
/* |
static_assert(std::has_trivial_default_constructor<tuple_type>::value, |
"! triv default"); |
static_assert(std::has_trivial_copy_assign<tuple_type>::value, |
"! triv assign"); |
static_assert(std::is_trivial<tuple_type>::value, "! triv"); |
static_assert(std::is_pod<tuple_type>::value, "! pod"); |
*/ |
} |
|
int main() |
{ |
test_trivial(); |
return 0; |
} |
/requirements/explicit_instantiation.cc
0,0 → 1,24
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2007, 2009 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> |
|
template class std::tuple<short, int, double>; |
/tuple_element.cc
0,0 → 1,37
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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> |
|
using namespace std; |
|
struct foo |
{ }; |
|
int |
main() |
{ |
// As foo isn't constructible from anything else, this |
// lets us check if type is returning foo when it should |
foo q1; |
tuple_element<0,tuple<foo,void,int> >::type q2(q1); |
tuple_element<2,tuple<void,int,foo> >::type q3(q1); |
} |
/creation_functions/23978.cc
0,0 → 1,45
// { dg-options "-std=gnu++0x" } |
// |
// Copyright (C) 2007, 2009 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; |
} |
/creation_functions/48476.cc
0,0 → 1,85
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2011 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; |
} |
/creation_functions/tuple_cat.cc
0,0 → 1,131
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2011 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); |
} |
/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 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; |
} |
/creation_functions/tie.cc
0,0 → 1,42
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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); |
} |
/creation_functions/tie2.cc
0,0 → 1,38
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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++" ); |
} |
/creation_functions/constexpr.cc
0,0 → 1,87
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2011 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); |
} |
} |
|
// 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; |
} |
/creation_functions/make_tuple.cc
0,0 → 1,37
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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); |
} |
/swap.cc
0,0 → 1,111
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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 tuple. If the implementation changed |
// this test may begin to fail. |
|
#include <tuple> |
#include <utility> |
#include <testsuite_hooks.h> |
|
struct MoveOnly |
{ |
explicit MoveOnly (int j) : i(j) { } |
|
MoveOnly (MoveOnly&& m) : i(m.i) { } |
|
MoveOnly& operator=(MoveOnly&& m) |
{ i = m.i; return *this; } |
|
MoveOnly(MoveOnly const&) = delete; |
MoveOnly& operator=(MoveOnly const&) = delete; |
|
bool operator==(MoveOnly const& m) |
{ return i == m.i; } |
|
void swap(MoveOnly& m) |
{ std::swap(m.i, i); } |
|
int i; |
}; |
|
void swap(MoveOnly& m1, MoveOnly& m2) |
{ m1.swap(m2); } |
|
MoveOnly |
make_move_only (int i) |
{ return MoveOnly(i); } |
|
void test01() |
{ |
bool test __attribute__((unused)) = true; |
|
std::tuple<> t1, t2; |
std::swap(t1, t2); |
|
VERIFY( t1 == t2 ); |
} |
|
void test02() |
{ |
bool test __attribute__((unused)) = true; |
|
std::tuple<int> t1(1), t2(2); |
std::swap(t1, t2); |
|
VERIFY( std::get<0>(t1) == 2 && std::get<0>(t2) == 1 ); |
} |
|
void test03() |
{ |
bool test __attribute__((unused)) = true; |
|
std::tuple<int, float> t1(1, 1.0f), t2(2, 2.0f); |
std::swap(t1, t2); |
|
VERIFY( std::get<0>(t1) == 2 && std::get<0>(t2) == 1 ); |
VERIFY( std::get<1>(t1) == 2.0f && std::get<1>(t2) == 1.0f ); |
} |
|
void test04() |
{ |
bool test __attribute__((unused)) = true; |
|
std::tuple<int, float, MoveOnly> |
t1(1, 1.0f, make_move_only(1)), |
t2(2, 2.0f, make_move_only(2)); |
|
std::swap(t1, t2); |
|
VERIFY( std::get<0>(t1) == 2 && std::get<0>(t2) == 1 ); |
VERIFY( std::get<1>(t1) == 2.0f && std::get<1>(t2) == 1.0f ); |
VERIFY( std::get<2>(t1) == make_move_only(2) |
&& std::get<2>(t2) == make_move_only(1) ); |
} |
|
int main() |
{ |
test01(); |
test02(); |
test03(); |
test04(); |
return 0; |
} |
/cv_tuple_size.cc
0,0 → 1,45
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2011 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> |
|
void |
test01() |
{ |
bool test __attribute__((unused)) = true; |
using namespace std; |
|
VERIFY( tuple_size<const tuple<> >::value == 0 ); |
VERIFY( tuple_size<volatile tuple<int> >::value == 1 ); |
VERIFY( tuple_size<const volatile tuple<void> >::value == 1 ); |
|
typedef tuple<int, const int&, void> test_tuple1; |
VERIFY( tuple_size<const test_tuple1>::value == 3 ); |
VERIFY( tuple_size<const volatile test_tuple1>::value == 3 ); |
VERIFY( tuple_size<volatile tuple<tuple<void> > >::value == 1 ); |
} |
|
int main() |
{ |
test01(); |
return 0; |
} |
/moveable2.cc
0,0 → 1,62
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2008, 2009, 2010, 2011 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 <utility> |
|
struct MoveOnly |
{ |
MoveOnly () { } |
|
MoveOnly (MoveOnly&&) { } |
|
MoveOnly& operator=(MoveOnly&&) |
{ return *this; } |
|
MoveOnly(MoveOnly const&) = delete; |
MoveOnly& operator=(MoveOnly const&) = delete; |
}; |
|
MoveOnly |
make_move_only () |
{ return MoveOnly(); } |
|
// http://gcc.gnu.org/ml/libstdc++/2008-02/msg00046.html |
void test01() |
{ |
typedef std::tuple<MoveOnly> move_only_tuple; |
|
move_only_tuple t1(make_move_only()); |
move_only_tuple t2(std::move(t1)); |
move_only_tuple t3 = std::move(t2); |
t1 = std::move(t3); |
|
typedef std::tuple<MoveOnly, MoveOnly> move_only_tuple2; |
|
move_only_tuple2 t4(make_move_only(), make_move_only()); |
move_only_tuple2 t5(std::move(t4)); |
move_only_tuple2 t6 = std::move(t5); |
t4 = std::move(t6); |
} |
|
int main() |
{ |
test01(); |
return 0; |
} |
/cons/48476.cc
0,0 → 1,27
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2011 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> |
|
void f() |
{ |
int i = 0; |
std::tuple<int&, int> t __attribute__((unused)) = std::forward_as_tuple(i, 0); |
} |
/cons/41530.cc
0,0 → 1,34
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2009 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> |
|
class A {}; |
class B : public A {}; |
|
// PR libstdc++/41530 |
void test01() |
{ |
std::tuple<B*> b; |
std::tuple<A*> a1(b); |
std::tuple<A*> a2(std::move(b)); |
} |
/cons/big_tuples.cc
0,0 → 1,105
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009, 2010 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> // for pair |
#include <testsuite_hooks.h> |
|
using namespace std; |
|
// A simple class without conversions to check some things |
struct foo |
{ }; |
|
void |
test_constructors() |
{ |
bool test __attribute__((unused)) = true; |
|
int x1=0,x2=0; |
const int &z1=x1; |
|
// Test empty constructor |
tuple<> ta __attribute__((unused)); |
tuple<int,int> tb; |
// Test construction from values |
tuple<int,int> tc(x1,x2); |
tuple<int,int&> td(x1,x2); |
tuple<const int&> te(z1); |
x1=1; |
x2=1; |
VERIFY(get<0>(td) == 0 && get<1>(td) == 1 && get<0>(te) == 1); |
|
// Test identical tuple copy constructor |
tuple<int,int> tf(tc); |
tuple<int,int> tg(td); |
tuple<const int&> th(te); |
// Test different tuple copy constructor |
tuple<int,double> ti(tc); |
tuple<int,double> tj(td); |
// Test constructing from a pair |
pair<int,int> pair1(1,1); |
const pair<int,int> pair2(pair1); |
tuple<int,int> tl(pair1); |
tuple<int,const int&> tm(pair1); |
tuple<int,int> tn(pair2); |
tuple<int,const int&> to(pair2); |
} |
|
int |
main(void) |
{ |
//test construction |
typedef tuple<int,int,int,int,int,int,int,int,int,int> type1; |
type1 a(0, 0, 0, 0, 0, 0, 0, 0, 0, 1); |
type1 b(0, 0, 0, 0, 0, 0, 0, 0, 0, 2); |
type1 c(a); |
typedef tuple<int,int,int,int,int,int,int,int,int,char> type2; |
type2 d(0, 0, 0, 0, 0, 0, 0, 0, 0, 3); |
type1 e(d); |
typedef tuple<foo,int,int,int,int,int,int,int,int,foo> type3; |
// get |
VERIFY(get<9>(a)==1 && get<9>(b)==2); |
// comparisons |
VERIFY(a==a && !(a!=a) && a<=a && a>=a && !(a<a) && !(a>a)); |
VERIFY(!(a==b) && a!=b && a<=b && a<b && !(a>=b) && !(a>b)); |
//tie |
{ |
int i = 0; |
tie(ignore, ignore, ignore, ignore, ignore, ignore, ignore, ignore, |
ignore, i) = a; |
VERIFY(i == 1); |
} |
//test_assignment |
a=d; |
a=b; |
//make_tuple |
make_tuple(0, 0, 0, 0, 0, 0, 0, 0, 0, 0); |
|
//tuple_size |
VERIFY(tuple_size<type3>::value == 10); |
//tuple_element |
{ |
foo q1; |
tuple_element<0,type3>::type q2(q1); |
tuple_element<9,type3>::type q3(q1); |
} |
} |
/cons/converting.cc
0,0 → 1,37
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2010 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> |
|
// http://gcc.gnu.org/ml/libstdc++/2008-02/msg00047.html |
std::tuple<int> ts1; |
std::tuple<unsigned> tu1(ts1); |
|
std::tuple<int, int> ts2; |
std::tuple<unsigned, unsigned> tu2(ts2); |
|
std::tuple<int, int, int> ts3; |
std::tuple<unsigned, unsigned, unsigned> tu3(ts3); |
|
std::tuple<int, unsigned> tm2; |
std::tuple<unsigned, int> tm2_(tm2); |
|
std::tuple<int, unsigned, int> tm3; |
std::tuple<unsigned, int, unsigned> tm3_(tm3); |
/cons/noexcept_move_construct.cc
0,0 → 1,59
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// 2011-05-20 Paolo Carlini <paolo.carlini@oracle.com> |
// |
// Copyright (C) 2011 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 <testsuite_tr1.h> |
|
using namespace __gnu_test; |
|
typedef std::tuple<int> tt1; |
typedef std::tuple<int, double> tt2; |
typedef std::tuple<short, double, int> tt3; |
typedef std::tuple<short, NoexceptMoveConsClass, double> tt4; |
typedef std::tuple<NoexceptMoveConsClass, |
NoexceptMoveConsClass, double> tt5; |
typedef std::tuple<NoexceptMoveConsClass, |
NoexceptMoveConsClass, |
NoexceptMoveConsClass> tt6; |
typedef std::tuple<ExceptMoveConsClass> tt7; |
typedef std::tuple<ExceptMoveConsClass, double> tt8; |
typedef std::tuple<short, double, ExceptMoveConsClass> tt9; |
typedef std::tuple<ExceptMoveConsClass, double, |
ExceptMoveConsClass> tt10; |
typedef std::tuple<NoexceptMoveConsClass, |
ExceptMoveConsClass> tt11; |
typedef std::tuple<int, |
NoexceptMoveConsClass, |
ExceptMoveConsClass> tt12; |
|
static_assert(std::is_nothrow_move_constructible<tt1>::value, "Error"); |
static_assert(std::is_nothrow_move_constructible<tt2>::value, "Error"); |
static_assert(std::is_nothrow_move_constructible<tt3>::value, "Error"); |
static_assert(std::is_nothrow_move_constructible<tt4>::value, "Error"); |
static_assert(std::is_nothrow_move_constructible<tt5>::value, "Error"); |
static_assert(std::is_nothrow_move_constructible<tt6>::value, "Error"); |
static_assert(!std::is_nothrow_move_constructible<tt7>::value, "Error"); |
static_assert(!std::is_nothrow_move_constructible<tt8>::value, "Error"); |
static_assert(!std::is_nothrow_move_constructible<tt9>::value, "Error"); |
static_assert(!std::is_nothrow_move_constructible<tt10>::value, "Error"); |
static_assert(!std::is_nothrow_move_constructible<tt11>::value, "Error"); |
static_assert(!std::is_nothrow_move_constructible<tt12>::value, "Error"); |
/cons/allocators.cc
0,0 → 1,169
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2011 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/>. |
|
// 20.4.2.1 [tuple.cnstr] Allocator-extended constructors |
|
#include <memory> |
#include <tuple> |
#include <testsuite_hooks.h> |
|
struct MyAlloc { }; |
|
// type that can't be constructed with an allocator |
struct CannotUse |
{ |
CannotUse(int = 0, int = 0) : ok(true) { } |
|
bool ok; |
}; |
|
// type that can be constructed with an allocator |
// but which has uses_allocator == false |
struct DoesNotUse |
{ |
typedef MyAlloc allocator_type; |
|
DoesNotUse(int = 0) : ok(true) { } |
DoesNotUse(std::allocator_arg_t, MyAlloc, int = 0) : ok(false) { } |
DoesNotUse(MyAlloc) : ok(false) { } |
DoesNotUse(int, MyAlloc) : ok(false) { } |
|
DoesNotUse(const DoesNotUse&) : ok(true) { } |
DoesNotUse(std::allocator_arg_t, MyAlloc, const DoesNotUse&) : ok(false) { } |
DoesNotUse(const DoesNotUse&, MyAlloc) : ok(false) { } |
|
DoesNotUse(DoesNotUse&&) : ok(true) { } |
DoesNotUse(std::allocator_arg_t, MyAlloc, DoesNotUse&&) : ok(false) { } |
DoesNotUse(DoesNotUse&&, MyAlloc) : ok(false) { } |
|
bool ok; |
}; |
|
namespace std |
{ |
template<typename A> |
struct uses_allocator<DoesNotUse, A> : false_type { }; |
} |
|
// type that can be constructed with an allocator as second argument |
struct UsesWithTag |
{ |
typedef MyAlloc allocator_type; |
|
UsesWithTag(int = 0) : ok(false) { } |
UsesWithTag(std::allocator_arg_t, MyAlloc, int = 0) : ok(true) { } |
UsesWithTag(MyAlloc) : ok(false) { } |
UsesWithTag(int, MyAlloc) : ok(false) { } |
|
UsesWithTag(const UsesWithTag&) : ok(false) { } |
UsesWithTag(std::allocator_arg_t, MyAlloc, const UsesWithTag&) : ok(true) { } |
UsesWithTag(const UsesWithTag&, MyAlloc) : ok(false) { } |
|
UsesWithTag(UsesWithTag&&) : ok(false) { } |
UsesWithTag(std::allocator_arg_t, MyAlloc, UsesWithTag&&) : ok(true) { } |
UsesWithTag(UsesWithTag&&, MyAlloc) : ok(false) { } |
|
bool ok; |
}; |
|
// type that can be constructed with an allocator as last argument |
struct UsesWithoutTag |
{ |
typedef MyAlloc allocator_type; |
|
UsesWithoutTag(int = 0) : ok(false) { } |
UsesWithoutTag(MyAlloc) : ok(true) { } |
UsesWithoutTag(int, MyAlloc) : ok(true) { } |
|
UsesWithoutTag(const UsesWithoutTag&) : ok(false) { } |
UsesWithoutTag(const UsesWithoutTag&, MyAlloc) : ok(true) { } |
|
UsesWithoutTag(UsesWithoutTag&&) : ok(false) { } |
UsesWithoutTag(UsesWithoutTag&&, MyAlloc) : ok(true) { } |
|
bool ok; |
}; |
|
void test01() |
{ |
bool test __attribute__((unused)) = true; |
using std::allocator_arg; |
using std::tuple; |
using std::make_tuple; |
using std::get; |
|
typedef CannotUse T1; |
typedef DoesNotUse T2; |
typedef UsesWithTag T3; |
typedef UsesWithoutTag T4; |
typedef tuple<T1, T2, T3, T4> test_type; |
|
MyAlloc a; |
|
// default construction |
test_type t1(allocator_arg, a); |
VERIFY( get<0>(t1).ok ); |
VERIFY( get<1>(t1).ok ); |
VERIFY( get<2>(t1).ok ); |
VERIFY( get<3>(t1).ok ); |
|
// copy construction |
test_type t2(allocator_arg, a, t1); |
VERIFY( get<0>(t2).ok ); |
VERIFY( get<1>(t2).ok ); |
VERIFY( get<2>(t2).ok ); |
VERIFY( get<3>(t2).ok ); |
|
// move construction |
test_type t3(allocator_arg, a, std::move(t1)); |
VERIFY( get<0>(t3).ok ); |
VERIFY( get<1>(t3).ok ); |
VERIFY( get<2>(t3).ok ); |
VERIFY( get<3>(t3).ok ); |
|
// construction from int |
test_type t4(allocator_arg, a, 1, 2, 3, 4); |
VERIFY( get<0>(t4).ok ); |
VERIFY( get<1>(t4).ok ); |
VERIFY( get<2>(t4).ok ); |
VERIFY( get<3>(t4).ok ); |
|
auto ints = make_tuple(1, 2, 3, 4); |
|
// construction from lvalue tuple of ints |
test_type t5(allocator_arg, a, ints); |
VERIFY( get<0>(t5).ok ); |
VERIFY( get<1>(t5).ok ); |
VERIFY( get<2>(t5).ok ); |
VERIFY( get<3>(t2).ok ); |
|
// construction from rvalue tuple of ints |
test_type t6(allocator_arg, a, std::move(ints)); |
VERIFY( get<0>(t6).ok ); |
VERIFY( get<1>(t6).ok ); |
VERIFY( get<2>(t6).ok ); |
VERIFY( get<3>(t6).ok ); |
|
} |
|
int main() |
{ |
test01(); |
return 0; |
} |
/cons/constexpr-2.cc
0,0 → 1,63
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2010, 2011 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 <memory> |
#include <testsuite_common_types.h> |
|
#include <iostream> |
|
// 2 element tuple |
int main() |
{ |
typedef std::tuple<int, int> tuple_type; |
|
// 01: default ctor |
__gnu_test::constexpr_default_constructible test1; |
test1.operator()<tuple_type>(); |
|
// 02: default copy ctor |
__gnu_test::constexpr_single_value_constructible test2; |
test2.operator()<tuple_type, tuple_type>(); |
|
// 03: element move ctor, single element |
const int i1(415); |
constexpr tuple_type t2 { 44, std::move(i1) }; |
|
// 04: element move ctor, two element |
const int i2(510); |
const int i3(408); |
constexpr tuple_type t4 { std::move(i2), std::move(i3) }; |
|
// 05: value-type conversion constructor |
const int i4(650); |
const int i5(310); |
constexpr tuple_type t8(i4, i5); |
|
// 06: pair conversion ctor |
test2.operator()<tuple_type, std::pair<int, int>>(); |
test2.operator()<std::tuple<short, short>, std::pair<int, int>>(); |
test2.operator()<tuple_type, std::pair<short, short>>(); |
|
// 07: different-tuple-type conversion constructor |
test2.operator()<tuple_type, std::tuple<short, short>>(); |
test2.operator()<std::tuple<short, short>, tuple_type>(); |
|
return 0; |
} |
/cons/45228.cc
0,0 → 1,43
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2010 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> |
|
typedef std::tuple<int> Tuple_1; |
typedef std::tuple<int, int> Tuple_2; |
typedef std::tuple<int, int, int> Tuple_3; |
|
Tuple_1 A_1() { return Tuple_1(); } |
const Tuple_1 B_1() { return Tuple_1(); } |
|
Tuple_2 A_2() { return Tuple_2(); } |
const Tuple_2 B_2() { return Tuple_2(); } |
|
Tuple_3 A_3() { return Tuple_3(); } |
const Tuple_3 B_3() { return Tuple_3(); } |
|
Tuple_1 test_A_1(A_1()); |
Tuple_1 test_B_1(B_1()); |
|
Tuple_2 test_A_2(A_2()); |
Tuple_2 test_B_2(B_2()); |
|
Tuple_3 test_A_3(A_3()); |
Tuple_3 test_B_3(B_3()); |
/cons/constructor.cc
0,0 → 1,65
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2008, 2009, 2010 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> // for pair |
#include <testsuite_hooks.h> |
|
using namespace std; |
|
int |
main() |
{ |
bool test __attribute__((unused)) = true; |
|
int x1=0,x2=0; |
const int &z1=x1; |
|
// Test empty constructor |
tuple<> ta __attribute__((unused)); |
tuple<int,int> tb; |
// Test construction from values |
tuple<int,int> tc(x1,x2); |
tuple<int,int&> td(x1,x2); |
tuple<const int&> te(z1); |
x1=1; |
x2=1; |
VERIFY(get<0>(td) == 0 && get<1>(td) == 1 && get<0>(te) == 1); |
|
// Test identical tuple copy constructor |
tuple<int,int> tf(tc); |
tuple<int,int> tg(td); |
tuple<const int&> th(te); |
// Test different tuple copy constructor |
tuple<int,double> ti(tc); |
tuple<int,double> tj(td); |
//tuple<int&, int&> tk(tc); |
tuple<const int&, const int&> tl(tc); |
tuple<const int&, const int&> tm(tl); |
// Test constructing from a pair |
pair<int,int> pair1(1,1); |
const pair<int,int> pair2(pair1); |
tuple<int,int> tn(pair1); |
tuple<int,const int&> to(pair1); |
tuple<int,int> tp(pair2); |
tuple<int,const int&> tq(pair2); |
return 0; |
} |
/cons/constexpr-3.cc
0,0 → 1,60
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2011 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 <memory> |
#include <testsuite_common_types.h> |
|
#include <iostream> |
|
// 3 element tuple |
int main() |
{ |
typedef std::tuple<int, int, int> tuple_type; |
|
// 01: default ctor |
__gnu_test::constexpr_default_constructible test1; |
test1.operator()<tuple_type>(); |
|
// 02: default copy ctor |
__gnu_test::constexpr_single_value_constructible test2; |
test2.operator()<tuple_type, tuple_type>(); |
|
// 03: element move ctor, single element |
const int i1(415); |
constexpr tuple_type t2 { 44, 55, std::move(i1) }; |
|
// 04: element move ctor, three element |
const int i2(510); |
const int i3(408); |
const int i4(650); |
constexpr tuple_type t4 { std::move(i2), std::move(i3), std::move(i4) }; |
|
// 05: value-type conversion constructor |
const int i5(310); |
const int i6(310); |
const int i7(310); |
constexpr tuple_type t8(i5, i6, i7); |
|
// 06: different-tuple-type conversion constructor |
test2.operator()<tuple_type, std::tuple<short, short, short>>(); |
test2.operator()<std::tuple<short, short, short>, tuple_type>(); |
|
return 0; |
} |
/cons/assignment.cc
0,0 → 1,52
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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; |
|
tuple<> ta; |
tuple<> tb; |
ta = tb; |
|
tuple<int> tc(1); |
tuple<int> td(0); |
td = tc; |
VERIFY(get<0>(td) == 1); |
|
int i=0; |
tuple<int&> te(i); |
te = tc; |
VERIFY(i == 1); |
|
tuple<const int&> tf(tc); |
|
get<0>(tc) = 2; |
VERIFY(get<0>(tf) == 2); |
tuple<double> tg; |
tg = tc; |
} |
/cons/44487.cc
0,0 → 1,51
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2010 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> |
|
int x, y; |
|
std::tuple<int&, int&> |
foo1() |
{ |
std::pair<int&, int&> blah(x, y); |
return blah; |
} |
|
std::tuple<int&, int&> |
foo2() |
{ |
const std::pair<int&, int&> blah(x, y); |
return blah; |
} |
|
std::tuple<int&, int&> |
foo3() |
{ |
std::pair<int&, int&> blah(x, y); |
return std::tuple<int&, int&>(std::move(blah)); |
} |
|
std::tuple<int&, int&> |
foo4() |
{ |
const std::pair<int&, int&> blah(x, y); |
return std::tuple<int&, int&>(std::move(blah)); |
} |
/noexcept_swap.cc
0,0 → 1,116
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// 2011-05-19 Paolo Carlini <paolo.carlini@oracle.com> |
// |
// Copyright (C) 2011 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 <testsuite_tr1.h> |
|
using namespace __gnu_test; |
|
typedef std::tuple<int> tt1; |
typedef std::tuple<int, double> tt2; |
typedef std::tuple<short, double, int> tt3; |
typedef std::tuple<short, NoexceptMoveAssignClass, double> tt4; |
typedef std::tuple<ExceptMoveAssignClass> tt5; |
typedef std::tuple<ExceptMoveAssignClass, double> tt6; |
typedef std::tuple<short, double, ExceptMoveAssignClass> tt7; |
typedef std::tuple<ExceptMoveConsClass> tt8; |
typedef std::tuple<int, ExceptMoveConsClass> tt9; |
typedef std::tuple<ExceptMoveConsClass, short, double> tt10; |
typedef std::tuple<short, NoexceptMoveConsClass, double> tt11; |
typedef std::tuple<NoexceptMoveConsClass> tt12; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass> tt13; |
typedef std::tuple<ExceptMoveConsNoexceptMoveAssignClass> tt14; |
typedef std::tuple<NoexceptMoveConsExceptMoveAssignClass> tt15; |
typedef std::tuple<ExceptMoveConsExceptMoveAssignClass> tt16; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass, |
double> tt17; |
typedef std::tuple<double, |
NoexceptMoveConsNoexceptMoveAssignClass, |
short> tt18; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass, |
NoexceptMoveConsNoexceptMoveAssignClass, |
char> tt19; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass, |
NoexceptMoveConsNoexceptMoveAssignClass, |
NoexceptMoveConsNoexceptMoveAssignClass> tt20; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass, |
ExceptMoveConsNoexceptMoveAssignClass, |
NoexceptMoveConsNoexceptMoveAssignClass> tt21; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass, |
ExceptMoveConsNoexceptMoveAssignClass, |
NoexceptMoveConsExceptMoveAssignClass> tt22; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass, |
NoexceptMoveConsNoexceptMoveAssignClass, |
ExceptMoveConsExceptMoveAssignClass> tt23; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass, |
short, ExceptMoveConsExceptMoveAssignClass> tt24; |
typedef std::tuple<NoexceptMoveConsNoexceptMoveAssignClass, |
short, ExceptMoveConsExceptMoveAssignClass> tt25; |
|
static_assert(noexcept(std::declval<tt1&>().swap(std::declval<tt1&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt2&>().swap(std::declval<tt2&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt3&>().swap(std::declval<tt3&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt4&>().swap(std::declval<tt4&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt5&>().swap(std::declval<tt5&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt6&>().swap(std::declval<tt6&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt7&>().swap(std::declval<tt7&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt8&>().swap(std::declval<tt8&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt9&>().swap(std::declval<tt9&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt10&>().swap(std::declval<tt10&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt11&>().swap(std::declval<tt11&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt12&>().swap(std::declval<tt12&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt13&>().swap(std::declval<tt13&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt14&>().swap(std::declval<tt14&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt15&>().swap(std::declval<tt15&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt16&>().swap(std::declval<tt16&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt17&>().swap(std::declval<tt17&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt18&>().swap(std::declval<tt18&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt19&>().swap(std::declval<tt19&>())), |
"Error"); |
static_assert(noexcept(std::declval<tt20&>().swap(std::declval<tt20&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt21&>().swap(std::declval<tt21&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt22&>().swap(std::declval<tt22&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt23&>().swap(std::declval<tt23&>())), |
"Error"); |
static_assert(!noexcept(std::declval<tt24&>().swap(std::declval<tt24&>())), |
"Error"); |
/noexcept_move_assign.cc
0,0 → 1,59
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// 2011-05-19 Paolo Carlini <paolo.carlini@oracle.com> |
// |
// Copyright (C) 2011 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 <testsuite_tr1.h> |
|
using namespace __gnu_test; |
|
typedef std::tuple<int> tt1; |
typedef std::tuple<int, double> tt2; |
typedef std::tuple<short, double, int> tt3; |
typedef std::tuple<short, NoexceptMoveAssignClass, double> tt4; |
typedef std::tuple<NoexceptMoveAssignClass, |
NoexceptMoveAssignClass, double> tt5; |
typedef std::tuple<NoexceptMoveAssignClass, |
NoexceptMoveAssignClass, |
NoexceptMoveAssignClass> tt6; |
typedef std::tuple<ExceptMoveAssignClass> tt7; |
typedef std::tuple<ExceptMoveAssignClass, double> tt8; |
typedef std::tuple<short, double, ExceptMoveAssignClass> tt9; |
typedef std::tuple<ExceptMoveAssignClass, double, |
ExceptMoveAssignClass> tt10; |
typedef std::tuple<NoexceptMoveAssignClass, |
ExceptMoveAssignClass> tt11; |
typedef std::tuple<int, |
NoexceptMoveAssignClass, |
ExceptMoveAssignClass> tt12; |
|
static_assert(std::is_nothrow_move_assignable<tt1>::value, "Error"); |
static_assert(std::is_nothrow_move_assignable<tt2>::value, "Error"); |
static_assert(std::is_nothrow_move_assignable<tt3>::value, "Error"); |
static_assert(std::is_nothrow_move_assignable<tt4>::value, "Error"); |
static_assert(std::is_nothrow_move_assignable<tt5>::value, "Error"); |
static_assert(std::is_nothrow_move_assignable<tt6>::value, "Error"); |
static_assert(!std::is_nothrow_move_assignable<tt7>::value, "Error"); |
static_assert(!std::is_nothrow_move_assignable<tt8>::value, "Error"); |
static_assert(!std::is_nothrow_move_assignable<tt9>::value, "Error"); |
static_assert(!std::is_nothrow_move_assignable<tt10>::value, "Error"); |
static_assert(!std::is_nothrow_move_assignable<tt11>::value, "Error"); |
static_assert(!std::is_nothrow_move_assignable<tt12>::value, "Error"); |
/51365.cc
0,0 → 1,27
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2011 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> |
|
// libstdc++/51365 |
|
struct F final { }; |
std::tuple<F> t; |
|
/tuple_size.cc
0,0 → 1,38
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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; |
|
VERIFY(tuple_size<tuple<> >::value == 0); |
VERIFY(tuple_size<tuple<int> >::value == 1); |
VERIFY(tuple_size<tuple<void> >::value == 1); |
typedef tuple<int,const int&,void> test_tuple1; |
VERIFY(tuple_size<test_tuple1>::value == 3); |
VERIFY(tuple_size<tuple<tuple<void> > >::value == 1); |
} |
/comparison_operators/35480_neg.cc
0,0 → 1,33
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2008, 2009 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> |
|
// libstdc++/35480 |
void test01() |
{ |
std::tuple<int> t1( 1 ); |
std::tuple<int, int> t2( 1, 2 ); |
if ( t1 < t2 ) {} // { dg-error "here" } |
if ( t1 == t2 ) {} // { dg-error "here" } |
} |
// { dg-prune-output "incomplete type" } |
/comparison_operators/comparisons.cc
0,0 → 1,49
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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; |
|
bool test __attribute__((unused)) = true; |
|
#define TEST1(x) VERIFY( x == x && !(x != x) && x <= x && !(x < x) ) |
|
int |
main() |
{ |
int i=0; |
int j=0; |
int k=2; |
tuple<int, int, int> a(0, 0, 0); |
tuple<int, int, int> b(0, 0, 1); |
tuple<int& , int& , int&> c(i,j,k); |
tuple<const int&, const int&, const int&> d(c); |
TEST1(a); |
TEST1(b); |
TEST1(c); |
TEST1(d); |
VERIFY(!(a > a) && !(b > b)); |
VERIFY(a >= a && b >= b); |
VERIFY(a < b && !(b < a) && a <= b && !(b <= a)); |
VERIFY(b > a && !(a > b) && b >= a && !(a >= b)); |
} |
/element_access/get.cc
0,0 → 1,44
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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 j=1; |
const int k=2; |
tuple<int,int &,const int&> a(0,j,k); |
const tuple<int,int &,const int&> b(1,j,k); |
VERIFY(get<0>(a)==0 && get<1>(a)==1 && get<2>(a)==2); |
get<0>(a)=3; |
get<1>(a)=4; |
VERIFY(get<0>(a)==3 && get<1>(a)==4); |
VERIFY(j==4); |
get<1>(b)=5; |
VERIFY(get<0>(b)==1 && get<1>(b)==5 && get<2>(b)==2); |
VERIFY(j==5); |
} |
/element_access/get2.cc
0,0 → 1,41
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// 2011-05-17 Paolo Carlini <paolo.carlini@oracle.com> |
// |
// Copyright (C) 2011 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> |
|
void test01() |
{ |
std::tuple<int> t1; |
|
int&& t1one __attribute__((unused)) = std::get<0>(std::move(t1)); |
|
std::tuple<float, int> t2; |
|
float&& t2one __attribute__((unused)) = std::get<0>(std::move(t2)); |
int&& t2two __attribute__((unused)) = std::get<1>(std::move(t2)); |
|
std::tuple<short, int, double> t3; |
|
short&& t3one __attribute__((unused)) = std::get<0>(std::move(t3)); |
int&& t3two __attribute__((unused)) = std::get<1>(std::move(t3)); |
double&& t3thr __attribute__((unused)) = std::get<2>(std::move(t3)); |
} |
/element_access/constexpr_get.cc
0,0 → 1,30
// { dg-options "-std=gnu++0x" } |
// { dg-do compile } |
|
// Copyright (C) 2011 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> |
|
std::tuple<int> ti; |
const std::tuple<int> cti; |
|
constexpr const int& cri = std::get<0>(cti); |
constexpr int& ri = std::get<0>(ti); |
constexpr int&& rri = std::get<0>(std::move(ti)); |
/moveable.cc
0,0 → 1,42
// { dg-options "-std=gnu++0x" } |
|
// Copyright (C) 2007, 2009 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 tuple. If the implementation changed |
// this test may begin to fail. |
|
#include <tuple> |
#include <utility> |
#include <testsuite_hooks.h> |
|
int main() |
{ |
bool test __attribute__((unused)) = true; |
|
std::tuple<int, double> a(1, 2.0), b; |
b = std::move(a); |
VERIFY( std::get<0>(b) == 1 && std::get<1>(b) == 2.0 ); |
VERIFY( std::get<0>(a) == 1 && std::get<1>(a) == 2.0 ); |
|
std::tuple<int, double> c(std::move(b)); |
VERIFY( std::get<0>(c) == 1 && std::get<1>(c) == 2.0 ); |
VERIFY( std::get<0>(b) == 1 && std::get<1>(b) == 2.0 ); |
return 0; |
} |
/cv_tuple_element.cc
0,0 → 1,34
// { dg-do compile } |
// { dg-options "-std=gnu++0x" } |
|
// 2011-05-19 Paolo Carlini <paolo.carlini@oracle.com> |
// |
// Copyright (C) 2011 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> |
|
using namespace std; |
|
static_assert(is_same<tuple_element<0, const tuple<double, void, int>>::type, |
const double>::value, "Error"); |
static_assert(is_same<tuple_element<1, volatile tuple<short, void>>::type, |
volatile void>::value, "Error"); |
static_assert(is_same<tuple_element<2, const volatile tuple<float, |
char, int>>::type, const volatile int>::value, "Error"); |