OpenCores
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");

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.