[multiple changes]
2011-04-13 Daniel Krugler <daniel.kruegler@googlemail.com> Paolo Carlini <paolo.carlini@oracle.com> PR libstdc++/48526 * include/std/type_traits (struct is_constructible): Re-implement, according to n3290. (struct is_default_constructible): Add. (struct is_destructible): Likewise. (struct __and_, __or_, __not_): Add and use throughout; reorder some facilities, other minor tweaks. * testsuite/util/testsuite_tr1.h: Add test types. * testsuite/20_util/is_constructible/value-2.cc: New. * testsuite/20_util/is_default_constructible/value.cc: Likewise. * testsuite/20_util/is_default_constructible/requirements/typedefs.cc: Likewise. * testsuite/20_util/is_default_constructible/requirements/ explicit_instantiation.cc: Likewise. * testsuite/20_util/is_destructible/value.cc: Likewise. * testsuite/20_util/is_destructible/requirements/typedefs.cc: Likewise. * testsuite/20_util/is_destructible/requirements/ explicit_instantiation.cc: Likewise. * testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Adjust dg-error line numbers. * testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc: Likewise. * testsuite/20_util/declval/requirements/1_neg.cc: Likewise. * testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Likewise. 2011-04-13 Paolo Carlini <paolo.carlini@oracle.com> * testsuite/20_util/is_function/value.cc: Add, adapted from the tr testsuite. * testsuite/20_util/is_function/requirements/typedefs.cc: Likewise. * testsuite/20_util/is_function/requirements/ explicit_instantiation.cc: Likewise. * testsuite/20_util/is_function/24808.cc: Likewise. * testsuite/20_util/is_function/35637.cc: Likewise. * testsuite/20_util/is_object/value.cc: Likewise. * testsuite/20_util/is_object/requirements/typedefs.cc: Likewise. * testsuite/20_util/is_object/requirements/explicit_instantiation.cc: : Likewise. * testsuite/20_util/is_object/24808.cc: Likewise. * testsuite/20_util/is_compound/value.cc: Likewise. * testsuite/20_util/is_compound/requirements/typedefs.cc: Likewise. * testsuite/20_util/is_compound/requirements/ explicit_instantiation.cc: Likewise. * testsuite/20_util/is_member_object_pointer/value.cc: Likewise. * testsuite/20_util/is_member_object_pointer/requirements/ typedefs.cc: Likewise. * testsuite/20_util/is_member_object_pointer/requirements/ explicit_instantiation.cc: Likewise. * testsuite/20_util/is_fundamental/value.cc: Likewise. * testsuite/20_util/is_fundamental/requirements/typedefs.cc: Likewise. * testsuite/20_util/is_fundamental/requirements/ explicit_instantiation.cc: Likewise. * testsuite/20_util/is_member_pointer/value.cc: Likewise. * testsuite/20_util/is_member_pointer/requirements/typedefs.cc: Likewise. * testsuite/20_util/is_member_pointer/requirements/ explicit_instantiation.cc: Likewise. * testsuite/20_util/is_member_function_pointer/value.cc: Likewise. * testsuite/20_util/is_member_function_pointer/ requirements/typedefs.cc: Likewise. * testsuite/20_util/is_member_function_pointer/requirements/ explicit_instantiation.cc: Likewise. * testsuite/20_util/is_convertible/value.cc: Minor tweak, adjust Copyright years. From-SVN: r172401
This commit is contained in:
Paolo Carlini
parent
12e0582473
commit
123c516a9e
|
|
@ -1,3 +1,73 @@
|
|||
2011-04-13 Daniel Krugler <daniel.kruegler@googlemail.com>
|
||||
Paolo Carlini <paolo.carlini@oracle.com>
|
||||
|
||||
PR libstdc++/48526
|
||||
* include/std/type_traits (struct is_constructible): Re-implement,
|
||||
according to n3290.
|
||||
(struct is_default_constructible): Add.
|
||||
(struct is_destructible): Likewise.
|
||||
(struct __and_, __or_, __not_): Add and use throughout; reorder some
|
||||
facilities, other minor tweaks.
|
||||
* testsuite/util/testsuite_tr1.h: Add test types.
|
||||
* testsuite/20_util/is_constructible/value-2.cc: New.
|
||||
* testsuite/20_util/is_default_constructible/value.cc: Likewise.
|
||||
* testsuite/20_util/is_default_constructible/requirements/typedefs.cc:
|
||||
Likewise.
|
||||
* testsuite/20_util/is_default_constructible/requirements/
|
||||
explicit_instantiation.cc: Likewise.
|
||||
* testsuite/20_util/is_destructible/value.cc: Likewise.
|
||||
* testsuite/20_util/is_destructible/requirements/typedefs.cc:
|
||||
Likewise.
|
||||
* testsuite/20_util/is_destructible/requirements/
|
||||
explicit_instantiation.cc: Likewise.
|
||||
* testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Adjust
|
||||
dg-error line numbers.
|
||||
* testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
|
||||
Likewise.
|
||||
* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
|
||||
* testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Likewise.
|
||||
|
||||
2011-04-13 Paolo Carlini <paolo.carlini@oracle.com>
|
||||
|
||||
* testsuite/20_util/is_function/value.cc: Add, adapted from the tr
|
||||
testsuite.
|
||||
* testsuite/20_util/is_function/requirements/typedefs.cc: Likewise.
|
||||
* testsuite/20_util/is_function/requirements/
|
||||
explicit_instantiation.cc: Likewise.
|
||||
* testsuite/20_util/is_function/24808.cc: Likewise.
|
||||
* testsuite/20_util/is_function/35637.cc: Likewise.
|
||||
* testsuite/20_util/is_object/value.cc: Likewise.
|
||||
* testsuite/20_util/is_object/requirements/typedefs.cc: Likewise.
|
||||
* testsuite/20_util/is_object/requirements/explicit_instantiation.cc:
|
||||
: Likewise.
|
||||
* testsuite/20_util/is_object/24808.cc: Likewise.
|
||||
* testsuite/20_util/is_compound/value.cc: Likewise.
|
||||
* testsuite/20_util/is_compound/requirements/typedefs.cc: Likewise.
|
||||
* testsuite/20_util/is_compound/requirements/
|
||||
explicit_instantiation.cc: Likewise.
|
||||
* testsuite/20_util/is_member_object_pointer/value.cc: Likewise.
|
||||
* testsuite/20_util/is_member_object_pointer/requirements/
|
||||
typedefs.cc: Likewise.
|
||||
* testsuite/20_util/is_member_object_pointer/requirements/
|
||||
explicit_instantiation.cc: Likewise.
|
||||
* testsuite/20_util/is_fundamental/value.cc: Likewise.
|
||||
* testsuite/20_util/is_fundamental/requirements/typedefs.cc: Likewise.
|
||||
* testsuite/20_util/is_fundamental/requirements/
|
||||
explicit_instantiation.cc: Likewise.
|
||||
* testsuite/20_util/is_member_pointer/value.cc: Likewise.
|
||||
* testsuite/20_util/is_member_pointer/requirements/typedefs.cc:
|
||||
Likewise.
|
||||
* testsuite/20_util/is_member_pointer/requirements/
|
||||
explicit_instantiation.cc: Likewise.
|
||||
* testsuite/20_util/is_member_function_pointer/value.cc: Likewise.
|
||||
* testsuite/20_util/is_member_function_pointer/
|
||||
requirements/typedefs.cc: Likewise.
|
||||
* testsuite/20_util/is_member_function_pointer/requirements/
|
||||
explicit_instantiation.cc: Likewise.
|
||||
|
||||
* testsuite/20_util/is_convertible/value.cc: Minor tweak, adjust
|
||||
Copyright years.
|
||||
|
||||
2011-04-12 Takaya Saito <gintensubaru@gmail.com>
|
||||
|
||||
PR libstdc++/48476
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -19,7 +19,7 @@
|
|||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-error "static assertion failed" "" { target *-*-* } 1134 }
|
||||
// { dg-error "static assertion failed" "" { target *-*-* } 1523 }
|
||||
|
||||
#include <utility>
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_compound<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_compound<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_compound;
|
||||
using namespace __gnu_test;
|
||||
|
||||
VERIFY( (test_category<is_compound, void>(false)) );
|
||||
VERIFY( (test_category<is_compound, char>(false)) );
|
||||
VERIFY( (test_category<is_compound, signed char>(false)) );
|
||||
VERIFY( (test_category<is_compound, unsigned char>(false)) );
|
||||
#ifdef _GLIBCXX_USE_WCHAR_T
|
||||
VERIFY( (test_category<is_compound, wchar_t>(false)) );
|
||||
#endif
|
||||
VERIFY( (test_category<is_compound, short>(false)) );
|
||||
VERIFY( (test_category<is_compound, unsigned short>(false)) );
|
||||
VERIFY( (test_category<is_compound, int>(false)) );
|
||||
VERIFY( (test_category<is_compound, unsigned int>(false)) );
|
||||
VERIFY( (test_category<is_compound, long>(false)) );
|
||||
VERIFY( (test_category<is_compound, unsigned long>(false)) );
|
||||
VERIFY( (test_category<is_compound, long long>(false)) );
|
||||
VERIFY( (test_category<is_compound, unsigned long long>(false)) );
|
||||
VERIFY( (test_category<is_compound, float>(false)) );
|
||||
VERIFY( (test_category<is_compound, double>(false)) );
|
||||
VERIFY( (test_category<is_compound, long double>(false)) );
|
||||
|
||||
// Sanity check.
|
||||
VERIFY( (test_category<is_compound, ClassType>(true)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,819 @@
|
|||
// { 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 <type_traits>
|
||||
#include <initializer_list>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
using namespace __gnu_test::construct_destruct;
|
||||
|
||||
static_assert(std::is_constructible<int, int>::value, "Error");
|
||||
static_assert(std::is_constructible<std::nullptr_t, std::nullptr_t>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<E, E>::value, "Error");
|
||||
static_assert(std::is_constructible<SE, SE>::value, "Error");
|
||||
static_assert(std::is_constructible<OpE, OpE>::value, "Error");
|
||||
static_assert(std::is_constructible<OpSE, OpSE>::value, "Error");
|
||||
static_assert(std::is_constructible<Empty, Empty>::value, "Error");
|
||||
static_assert(std::is_constructible<B, B>::value, "Error");
|
||||
static_assert(std::is_constructible<U, U>::value, "Error");
|
||||
static_assert(std::is_constructible<int B::*, int B::*>::value, "Error");
|
||||
static_assert(std::is_constructible<Ellipsis, Ellipsis>::value, "Error");
|
||||
static_assert(std::is_constructible<int*, int*>::value, "Error");
|
||||
static_assert(std::is_constructible<void*, void*>::value, "Error");
|
||||
static_assert(std::is_constructible<Any, Any>::value, "Error");
|
||||
static_assert(std::is_constructible<nAny, nAny>::value, "Error");
|
||||
static_assert(std::is_constructible<std::initializer_list<int>,
|
||||
std::initializer_list<int>>::value, "Error");
|
||||
static_assert(std::is_constructible<DelDef, DelDef>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract, Abstract>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[1], int[1]>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelCopy, const DelCopy&>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelCopy, DelCopy&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelCopy, DelCopy>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelDtor, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelDtor, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelDtor, DelDtor>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelDtor, DelDtor&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelDtor, const DelDtor&>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<DelEllipsis, const DelEllipsis&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<DelEllipsis, DelEllipsis&&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<DelEllipsis, DelEllipsis>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, std::nullptr_t>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, B>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, void() const>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, int[1]>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, int*>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, void*>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, int B::*>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, int D::*>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, Abstract>::value, "Error");
|
||||
static_assert(!std::is_constructible<int, DelImplicitTo<int>>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t,
|
||||
DelImplicitTo<std::nullptr_t>>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&,
|
||||
DelImplicitTo<const int&>>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, int>::value, "Error");
|
||||
static_assert(std::is_constructible<void*, int*>::value, "Error");
|
||||
static_assert(!std::is_constructible<int*, void*>::value, "Error");
|
||||
static_assert(std::is_constructible<int*, std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, int*>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, void*>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, int[3]>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract, std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, Abstract>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract, int[]>::value, "Error");
|
||||
static_assert(std::is_constructible<B, D>::value, "Error");
|
||||
static_assert(!std::is_constructible<D, B>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[], int[1]>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[1], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[], Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[], std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[1], Abstract>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<const int*, int*>::value, "Error");
|
||||
static_assert(std::is_constructible<const void*, void*>::value, "Error");
|
||||
static_assert(std::is_constructible<const void*, int*>::value, "Error");
|
||||
static_assert(!std::is_constructible<int*, const void*>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<int, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, E2>::value, "Error");
|
||||
static_assert(std::is_constructible<E, E>::value, "Error");
|
||||
static_assert(std::is_constructible<bool, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, bool>::value, "Error");
|
||||
static_assert(std::is_constructible<double, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, double>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, std::nullptr_t>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<int, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, E2>::value, "Error");
|
||||
static_assert(std::is_constructible<OpE, OpE>::value, "Error");
|
||||
static_assert(std::is_constructible<bool, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, bool>::value, "Error");
|
||||
static_assert(std::is_constructible<double, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, double>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, std::nullptr_t>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, SE2>::value, "Error");
|
||||
static_assert(std::is_constructible<SE, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<bool, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, bool>::value, "Error");
|
||||
static_assert(!std::is_constructible<double, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, double>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, std::nullptr_t>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, SE2>::value, "Error");
|
||||
static_assert(std::is_constructible<OpSE, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<bool, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, bool>::value, "Error");
|
||||
static_assert(!std::is_constructible<double, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, double>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, std::nullptr_t>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<D*, B*>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile D*, B*>::value, "Error");
|
||||
static_assert(!std::is_constructible<D*, const volatile B*>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<D*, B* const>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile D*, B* const>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<D*, const volatile B* const>::value,
|
||||
"Error");
|
||||
|
||||
static_assert(!std::is_constructible<D*, B*&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile D*, B*&>::value, "Error");
|
||||
static_assert(!std::is_constructible<D*, const volatile B*&>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int B::*, int D::*>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile int B::*, int D::*>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<int B::*, const volatile int D::*>::value,
|
||||
"Error");
|
||||
|
||||
static_assert(!std::is_constructible<int B::*, int D::* const>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile int B::*,
|
||||
int D::* const>::value, "Error");
|
||||
static_assert(!std::is_constructible<int B::*,
|
||||
const volatile int D::* const>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int B::*, int D::*&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile int B::*,
|
||||
int D::*&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int B::*,
|
||||
const volatile int D::*&>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int B::*, int D::* const &>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const volatile int B::*,
|
||||
int D::* const &>::value, "Error");
|
||||
static_assert(!std::is_constructible<int B::*,
|
||||
const volatile int D::* const &>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int&&, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int&&, int&>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<B&, D&>::value, "Error");
|
||||
static_assert(std::is_constructible<B&&, D&&>::value, "Error");
|
||||
static_assert(std::is_constructible<const B&, D&>::value, "Error");
|
||||
static_assert(std::is_constructible<const B&&, D&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<B&, const D&>::value, "Error");
|
||||
static_assert(!std::is_constructible<B&&, const D&&>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<D&, B&>::value, "Error");
|
||||
static_assert(!std::is_constructible<D&&, B&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<D&, const B&>::value, "Error");
|
||||
static_assert(!std::is_constructible<D&&, const B&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const D&, B&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const D&&, B&&>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<B&&, B&>::value, "Error");
|
||||
static_assert(!std::is_constructible<B&&, D&>::value, "Error");
|
||||
static_assert(std::is_constructible<B&&, ImplicitTo<D&&>>::value, "Error");
|
||||
static_assert(std::is_constructible<B&&, ImplicitTo<D&&>&>::value, "Error");
|
||||
static_assert(std::is_constructible<int&&, double&>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&,
|
||||
ImplicitTo<int&>&>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&,
|
||||
ImplicitTo<int&>>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&,
|
||||
ExplicitTo<int&>&>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&,
|
||||
ExplicitTo<int&>>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<B&&, ExplicitTo<D&&>>::value, "Error");
|
||||
static_assert(std::is_constructible<B&&, ExplicitTo<D&&>&>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<B&, B&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<D&, B&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<B&, D&&>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<void(&)(), void(&)()>::value, "Error");
|
||||
static_assert(std::is_constructible<void(&&)(), void(&&)()>::value, "Error");
|
||||
static_assert(std::is_constructible<void(&&)(), void()>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void>::value, "Error" );
|
||||
static_assert(!std::is_constructible<void, int>::value, "Error" );
|
||||
static_assert(!std::is_constructible<void, int, double>::value, "Error" );
|
||||
|
||||
static_assert(!std::is_constructible<int&>::value, "Error" );
|
||||
static_assert(!std::is_constructible<const int&>::value, "Error" );
|
||||
static_assert(!std::is_constructible<int&, int, int>::value, "Error" );
|
||||
static_assert(!std::is_constructible<const int&, int, int>::value, "Error" );
|
||||
|
||||
static_assert(std::is_constructible<void(&)(), void()>::value, "Error");
|
||||
static_assert(std::is_constructible<void(&)(), void(&&)()>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<int&, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, const int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, int&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, const int&&>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&, int&>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&, int>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&, const int>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&, int&&>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&, const int&&>::value, "Error");
|
||||
static_assert(std::is_constructible<volatile int&, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile int&, const int&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<volatile int&, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile int&, int&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile int&, const int&&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<const volatile int&, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile int&, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile int&, const int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const volatile int&, int&&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const volatile int&, const int&&>::value,
|
||||
"Error");
|
||||
|
||||
static_assert(std::is_constructible<int&&, int>::value, "Error");
|
||||
static_assert(std::is_constructible<int&&, int&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&&, const int&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&&, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&&, const int&>::value, "Error");
|
||||
static_assert(std::is_constructible<int&&, double&>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&&, int>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&&, int&&>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&&, const int>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&&, const int&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&&, const int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int&&, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int&&, const int&>::value, "Error");
|
||||
static_assert(std::is_constructible<volatile int&&, int>::value, "Error");
|
||||
static_assert(std::is_constructible<volatile int&&, int&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile int&&, const int&&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<volatile int&&, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile int&&, const int&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<volatile int&&, double&>::value, "Error");
|
||||
static_assert(std::is_constructible<volatile const int&&, int>::value, "Error");
|
||||
static_assert(std::is_constructible<const volatile int&&, int&&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<const volatile int&&, const int>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<const volatile int&&, const int&&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<volatile int&&, const int&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const volatile int&&, int&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const volatile int&&,
|
||||
const int&>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<Empty&, Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&, const Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&, Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&, Empty&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&, const Empty&&>::value, "Error");
|
||||
static_assert(std::is_constructible<const Empty&, Empty&>::value, "Error");
|
||||
static_assert(std::is_constructible<const Empty&, Empty>::value, "Error");
|
||||
static_assert(std::is_constructible<const Empty&, const Empty>::value, "Error");
|
||||
static_assert(std::is_constructible<const Empty&, Empty&&>::value, "Error");
|
||||
static_assert(std::is_constructible<const Empty&, const Empty&&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<volatile Empty&, Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&, const Empty&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&, Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&, Empty&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&, const Empty&&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<const volatile Empty&, Empty&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const volatile Empty&, Empty>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const volatile Empty&,
|
||||
const Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile Empty&,
|
||||
Empty&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile Empty&,
|
||||
const Empty&&>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<Empty&&, Empty>::value, "Error");
|
||||
static_assert(std::is_constructible<Empty&&, Empty&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&&, const Empty&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&&, Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&&, const Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&&, double&>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&&, const double&>::value, "Error");
|
||||
static_assert(std::is_constructible<const Empty&&, Empty>::value, "Error");
|
||||
static_assert(std::is_constructible<const Empty&&, Empty&&>::value, "Error");
|
||||
static_assert(std::is_constructible<const Empty&&, const Empty>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<const Empty&&, const Empty&&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<Empty&&, const Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Empty&&, Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Empty&&, const Empty&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<volatile Empty&&, Empty>::value, "Error");
|
||||
static_assert(std::is_constructible<volatile Empty&&, Empty&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&&, const Empty&&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&&, Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&&, const Empty&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&&, double&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&&, const double&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<const volatile Empty&&, Empty>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<const volatile Empty&&, Empty&&>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<const volatile Empty&&,
|
||||
const Empty>::value, "Error");
|
||||
static_assert(std::is_constructible<const volatile Empty&&,
|
||||
const Empty&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<volatile Empty&&,
|
||||
const Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile Empty&&,
|
||||
Empty&>::value, "Error");
|
||||
static_assert(!std::is_constructible<const volatile Empty&&,
|
||||
const Empty&>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<Ellipsis, int>::value, "Error");
|
||||
static_assert(std::is_constructible<Ellipsis, Empty>::value, "Error");
|
||||
static_assert(std::is_constructible<Ellipsis, std::nullptr_t>::value, "Error");
|
||||
static_assert(std::is_constructible<Ellipsis, int[]>::value, "Error");
|
||||
static_assert(std::is_constructible<Ellipsis, int[1]>::value, "Error");
|
||||
static_assert(!std::is_constructible<Ellipsis, void>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<int(&)[1], int(&)[1]>::value, "Error");
|
||||
static_assert(std::is_constructible<const int(&)[1],
|
||||
int(&)[1]>::value, "Error");
|
||||
static_assert(std::is_constructible<volatile int(&)[1],
|
||||
int(&)[1]>::value, "Error");
|
||||
static_assert(std::is_constructible<const volatile int(&)[1],
|
||||
int(&)[1]>::value, "Error");
|
||||
static_assert(!std::is_constructible<int(&)[1],
|
||||
const int(&)[1]>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int(&)[1],
|
||||
volatile int(&)[1]>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<int(&)[], int(&)[]>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int(&)[1], int(&)[2]>::value, "Error");
|
||||
static_assert(!std::is_constructible<int(&)[1], int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, int(&)[1]>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<U, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<U, Empty>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void(), void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), Abstract>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), U>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), E>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), int[1]>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void() const,
|
||||
void() volatile>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, Abstract>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, std::nullptr_t>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<void() const, Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, U>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, int[1]>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void(int), void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<int, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<U, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[], void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[1], void()>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void(int) const,
|
||||
void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<int, void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract, void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, void() const>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<Empty, void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<U, void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[], void() const>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[1], void() const>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, Empty, B>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, Empty, Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, U, Empty>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, U, U>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, std::nullptr_t,
|
||||
std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, int[1], int[1]>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, int[], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, void(), void()>::value, "Error");
|
||||
static_assert(!std::is_constructible<void, void() const,
|
||||
void() volatile>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<bool, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const bool, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const std::nullptr_t, int, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const std::nullptr_t, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t, void, void>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const std::nullptr_t, void, void>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<E, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const E, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const E, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const E, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const SE, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const SE, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const SE, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpE, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpE, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpE, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpSE, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpSE, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpSE, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Empty, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Empty, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Empty, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<U, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const U, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<U, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const U, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<U, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const U, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<B, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const B, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<B, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const B, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<B, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const B, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<Any, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Any, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Any, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Any, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Any, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Any, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<nAny, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const nAny, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<nAny, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const nAny, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<FromArgs<>, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const FromArgs<>, int, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<FromArgs<>, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const FromArgs<>, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<FromArgs<>, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const FromArgs<>, void, void>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<Abstract, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Abstract, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Abstract, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<Abstract, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const Abstract, void, void>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<AbstractDelDtor, int, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const AbstractDelDtor, int, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<AbstractDelDtor, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const AbstractDelDtor, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<AbstractDelDtor, void, void>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const AbstractDelDtor, void, void>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<int[1], int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int[1], int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[1], void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int[1], void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int[1], void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int[1], void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, int&, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, void, int&>::value, "Error");
|
||||
static_assert(!std::is_constructible<int&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t&, int, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t&, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<std::nullptr_t&, void, void>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<E&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<E&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<E&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Empty&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<U&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<U&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<U&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<B&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<B&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<B&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<Any&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Any&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Any&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<nAny&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<nAny&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<FromArgs<>&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<FromArgs<>&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<FromArgs<>&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract&, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract&, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<Abstract&, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<int(&)[1], int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int(&)[1], void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<int(&)[1], void, void>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void(), int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), void(), int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void(), void(), void()>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<void() const, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, void, void>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, void() volatile,
|
||||
int>::value, "Error");
|
||||
static_assert(!std::is_constructible<void() const, void() volatile const,
|
||||
void() const>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<FromArgs<int>, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const FromArgs<int>, int, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<FromArgs<int>, void, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const FromArgs<int>, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<FromArgs<int, int>, void, int>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const FromArgs<int, int>, void,
|
||||
int>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<DelDtor, int, B, U>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelDtor, int, B, U>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelDtor, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelDtor, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelDtor>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelDtor>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelDtor, void*, void(&)()>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const DelDtor, void*, void(&)()>::value,
|
||||
"Error");
|
||||
|
||||
static_assert(!std::is_constructible<AbstractDelDtor>::value, "Error");
|
||||
static_assert(!std::is_constructible<const AbstractDelDtor>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelEllipsis>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, double>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelEllipsis, double>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<DelEllipsis, double, int&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<const DelEllipsis, double, int&>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<DelnAny>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelnAny>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelnAny, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelnAny, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<DelnAny, int, void*>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelnAny, int, void*>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<DelnAny, Empty, B, D>::value, "Error");
|
||||
static_assert(!std::is_constructible<const DelnAny, Empty, B, D>::value,
|
||||
"Error");
|
||||
|
||||
// Deleted members in unions with non-trivial members:
|
||||
static_assert(!std::is_constructible<NontrivialUnion>::value, "Error");
|
||||
static_assert(!std::is_constructible<NontrivialUnion,
|
||||
const NontrivialUnion&>::value, "Error");
|
||||
|
||||
// Unusual copy:
|
||||
static_assert(!std::is_constructible<UnusualCopy>::value, "Error");
|
||||
static_assert(!std::is_constructible<UnusualCopy, UnusualCopy>::value, "Error");
|
||||
static_assert(!std::is_constructible<UnusualCopy,
|
||||
UnusualCopy&&>::value, "Error");
|
||||
static_assert(!std::is_constructible<UnusualCopy,
|
||||
const UnusualCopy&>::value, "Error");
|
||||
static_assert(std::is_constructible<UnusualCopy, UnusualCopy&>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<FromArgs<int, char>,
|
||||
int, char>::value, "Error");
|
||||
static_assert(std::is_constructible<const FromArgs<int, char>,
|
||||
int, char>::value, "Error");
|
||||
static_assert(std::is_constructible<FromArgs<int, char>,
|
||||
int, int>::value, "Error");
|
||||
static_assert(std::is_constructible<const FromArgs<int, char>,
|
||||
int, int>::value, "Error");
|
||||
static_assert(std::is_constructible<nAny, int, int>::value, "Error");
|
||||
static_assert(std::is_constructible<const nAny, int, int>::value, "Error");
|
||||
static_assert(std::is_constructible<FromArgs<int, char>,
|
||||
ImplicitTo<int>, ImplicitTo<char>>::value, "Error");
|
||||
static_assert(std::is_constructible<const FromArgs<int, char>,
|
||||
ImplicitTo<int>, ImplicitTo<char>>::value, "Error");
|
||||
static_assert(std::is_constructible<Ellipsis, int, char>::value, "Error");
|
||||
static_assert(std::is_constructible<const Ellipsis, int, char>::value, "Error");
|
||||
static_assert(std::is_constructible<Ellipsis, B, U, int&>::value, "Error");
|
||||
static_assert(std::is_constructible<const Ellipsis,
|
||||
B, U, int&>::value, "Error");
|
||||
static_assert(std::is_constructible<nAny, B, U, int&>::value, "Error");
|
||||
static_assert(std::is_constructible<const nAny, B, U, int&>::value, "Error");
|
||||
static_assert(std::is_constructible<FromArgs<std::initializer_list<int>,
|
||||
std::initializer_list<B>>, std::initializer_list<int>,
|
||||
std::initializer_list<B>>::value, "Error");
|
||||
static_assert(std::is_constructible<const FromArgs<std::initializer_list<int>,
|
||||
std::initializer_list<B>>, std::initializer_list<int>,
|
||||
std::initializer_list<B>>::value, "Error");
|
||||
static_assert(std::is_constructible<FromArgs<std::initializer_list<int>,
|
||||
std::initializer_list<B>>, std::initializer_list<int>&,
|
||||
std::initializer_list<B>&>::value, "Error");
|
||||
static_assert(!std::is_constructible<FromArgs<std::initializer_list<int>&,
|
||||
std::initializer_list<B>&>, std::initializer_list<int>,
|
||||
std::initializer_list<B>>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<FromArgs<std::initializer_list<int>>,
|
||||
int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const
|
||||
FromArgs<std::initializer_list<int>>, int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<B[2], B, B>::value, "Error");
|
||||
static_assert(!std::is_constructible<const B[2], B, B>::value, "Error");
|
||||
static_assert(!std::is_constructible<U[2], U, U>::value, "Error");
|
||||
static_assert(!std::is_constructible<const U[2], U, U>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<E, E, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<const E, E, E>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, SE, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<const SE, SE, SE>::value, "Error");
|
||||
static_assert(!std::is_constructible<E, B, std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<const E, B, std::nullptr_t>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<SE, B, std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<const SE, B, std::nullptr_t>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<E, int[], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<const E, int[], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<SE, int[], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<const SE, int[], int[]>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<OpE, OpE, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpE, OpE, OpE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, OpSE, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpSE, OpSE, OpSE>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpE, B, std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpE, B, std::nullptr_t>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<OpSE, B, std::nullptr_t>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpSE, B, std::nullptr_t>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<OpE, int[], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpE, int[], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<OpSE, int[], int[]>::value, "Error");
|
||||
static_assert(!std::is_constructible<const OpSE, int[], int[]>::value, "Error");
|
||||
|
||||
static_assert(!std::is_constructible<int[], int, int>::value, "Error");
|
||||
static_assert(!std::is_constructible<const int[], int, int>::value, "Error");
|
||||
|
||||
static_assert(std::is_constructible<int&, ImplicitTo<int&>>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&, ImplicitTo<int&&>>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<int&&, ImplicitTo<int&&>>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&, ImplicitTo<int>>::value,
|
||||
"Error");
|
||||
|
||||
static_assert(!std::is_constructible<const int&, ExplicitTo<int>>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<int&&, ExplicitTo<int>>::value, "Error");
|
||||
|
||||
// Binding through reference-compatible type is required to perform
|
||||
// direct-initialization as described in [over.match.ref] p. 1 b. 1:
|
||||
static_assert(std::is_constructible<int&, ExplicitTo<int&>>::value, "Error");
|
||||
static_assert(std::is_constructible<const int&, ExplicitTo<int&&>>::value,
|
||||
"Error");
|
||||
static_assert(std::is_constructible<int&&, ExplicitTo<int&&>>::value, "Error");
|
||||
|
||||
// Binding through temporary behaves like copy-initialization,
|
||||
// see [dcl.init.ref] p. 5, very last sub-bullet:
|
||||
static_assert(!std::is_constructible<const int&, ExplicitTo<double&&>>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_constructible<int&&, ExplicitTo<double&&>>::value,
|
||||
"Error");
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
// 2009-10-29 Paolo Carlini <paolo.carlini@oracle.com>
|
||||
//
|
||||
// Copyright (C) 2009 Free Software Foundation, Inc.
|
||||
// Copyright (C) 2009, 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
|
||||
|
|
@ -58,6 +58,8 @@ void test01()
|
|||
VERIFY( (test_relationship<is_convertible, void, volatile void>(true)) );
|
||||
VERIFY( (test_relationship<is_convertible, double&, ExplicitClass>(true)) );
|
||||
|
||||
VERIFY( (test_relationship<is_convertible, int(int), int(&)(int)>(true)) );
|
||||
|
||||
// Negative tests.
|
||||
VERIFY( (test_relationship<is_convertible, const int*, int*>(false)) );
|
||||
VERIFY( (test_relationship<is_convertible, int*, float*>(false)) );
|
||||
|
|
@ -93,8 +95,6 @@ void test01()
|
|||
const volatile int&>(false)) );
|
||||
VERIFY( (test_relationship<is_convertible, volatile int,
|
||||
volatile int&>(false)) );
|
||||
VERIFY( (test_relationship<is_convertible, int(int), int(&)(int)>(true)) );
|
||||
|
||||
VERIFY( (test_relationship<is_convertible, int&, ExplicitClass>(false)) );
|
||||
VERIFY( (test_relationship<is_convertible, void*, ExplicitClass>(false)) );
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_default_constructible<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
// { dg-do compile }
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_default_constructible<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
// { 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 <type_traits>
|
||||
#include <initializer_list>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
using namespace __gnu_test::construct_destruct;
|
||||
|
||||
static_assert(std::is_default_constructible<int>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int const volatile>::value,
|
||||
"Error");
|
||||
static_assert(std::is_default_constructible<int*>::value, "Error");
|
||||
static_assert(std::is_default_constructible<void*>::value, "Error");
|
||||
static_assert(std::is_default_constructible<void* const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int B::*>::value, "Error");
|
||||
static_assert(std::is_default_constructible<void(*)()>::value, "Error");
|
||||
static_assert(std::is_default_constructible<std::nullptr_t>::value, "Error");
|
||||
static_assert(std::is_default_constructible<std::nullptr_t const>::value,
|
||||
"Error");
|
||||
static_assert(std::is_default_constructible<Empty>::value, "Error");
|
||||
static_assert(std::is_default_constructible<Empty const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<FromArgs<>>::value, "Error");
|
||||
static_assert(std::is_default_constructible<FromArgs<> const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<nAny>::value, "Error");
|
||||
static_assert(std::is_default_constructible<nAny const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<Ellipsis>::value, "Error");
|
||||
static_assert(std::is_default_constructible<Ellipsis const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<U>::value, "Error");
|
||||
static_assert(std::is_default_constructible<U const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<E>::value, "Error");
|
||||
static_assert(std::is_default_constructible<E const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<SE>::value, "Error");
|
||||
static_assert(std::is_default_constructible<SE const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<OpE>::value, "Error");
|
||||
static_assert(std::is_default_constructible<OpE const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<OpSE>::value, "Error");
|
||||
static_assert(std::is_default_constructible<OpSE const>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const int[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int[1][2]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const int[1][2]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<FromArgs<>[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const FromArgs<>[1]>::value,
|
||||
"Error");
|
||||
static_assert(std::is_default_constructible<U[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const U[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<Empty[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const Empty[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<Ellipsis[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const Ellipsis[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<std::nullptr_t[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const std::nullptr_t[1]>::value,
|
||||
"Error");
|
||||
static_assert(std::is_default_constructible<nAny[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const nAny[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<E[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const E[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<SE[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const SE[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<OpE[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const OpE[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<OpSE[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const OpSE[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int*[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int* const[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int B::*[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<int B::* const[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<std::initializer_list<int>>::value,
|
||||
"Error");
|
||||
static_assert(std::is_default_constructible<const
|
||||
std::initializer_list<int>>::value, "Error");
|
||||
static_assert(std::is_default_constructible<
|
||||
std::initializer_list<int>[1]>::value, "Error");
|
||||
static_assert(std::is_default_constructible<const
|
||||
std::initializer_list<int>[1]>::value, "Error");
|
||||
|
||||
static_assert(!std::is_default_constructible<void>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const void>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<Abstract>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const Abstract>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<Any>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const Any>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<FromArgs<int>>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const FromArgs<int>>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_default_constructible<int&>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<int&&>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<void()>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<void() const volatile>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_default_constructible<void(&)()>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<int(&)[1]>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<int(&)[]>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<int[]>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const int[]>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<int[][1][2]>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const int[][1][2]>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_default_constructible<Any[1]>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const Any[1]>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<FromArgs<int>[1]>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const FromArgs<int>[1]>::value,
|
||||
"Error");
|
||||
static_assert(!std::is_default_constructible<
|
||||
FromArgs<std::initializer_list<int>>>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const
|
||||
FromArgs<std::initializer_list<int>>>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const
|
||||
FromArgs<const std::initializer_list<int>>>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<DelDef>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const DelDef>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<DelCopy>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const DelCopy>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<DelDtor>::value, "Error");
|
||||
static_assert(!std::is_default_constructible<const DelDtor>::value, "Error");
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_destructible<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
// { dg-do compile }
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_destructible<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
// { 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 <type_traits>
|
||||
#include <initializer_list>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
using namespace __gnu_test::construct_destruct;
|
||||
|
||||
static_assert(std::is_destructible<int>::value, "Error");
|
||||
static_assert(std::is_destructible<const int>::value, "Error");
|
||||
static_assert(std::is_destructible<bool>::value, "Error");
|
||||
static_assert(std::is_destructible<const bool>::value, "Error");
|
||||
static_assert(std::is_destructible<int*>::value, "Error");
|
||||
static_assert(std::is_destructible<void*>::value, "Error");
|
||||
static_assert(std::is_destructible<int B::*>::value, "Error");
|
||||
static_assert(std::is_destructible<const int D::*>::value, "Error");
|
||||
static_assert(std::is_destructible<E>::value, "Error");
|
||||
static_assert(std::is_destructible<const E>::value, "Error");
|
||||
static_assert(std::is_destructible<SE>::value, "Error");
|
||||
static_assert(std::is_destructible<const SE>::value, "Error");
|
||||
static_assert(std::is_destructible<OpE>::value, "Error");
|
||||
static_assert(std::is_destructible<const OpE>::value, "Error");
|
||||
static_assert(std::is_destructible<OpSE>::value, "Error");
|
||||
static_assert(std::is_destructible<const OpSE>::value, "Error");
|
||||
static_assert(std::is_destructible<std::nullptr_t>::value, "Error");
|
||||
static_assert(std::is_destructible<const std::nullptr_t>::value, "Error");
|
||||
static_assert(std::is_destructible<B>::value, "Error");
|
||||
static_assert(std::is_destructible<const B>::value, "Error");
|
||||
static_assert(std::is_destructible<D>::value, "Error");
|
||||
static_assert(std::is_destructible<const D>::value, "Error");
|
||||
static_assert(std::is_destructible<Empty>::value, "Error");
|
||||
static_assert(std::is_destructible<const Empty>::value, "Error");
|
||||
static_assert(std::is_destructible<U>::value, "Error");
|
||||
static_assert(std::is_destructible<const U>::value, "Error");
|
||||
static_assert(std::is_destructible<Abstract>::value, "Error");
|
||||
static_assert(std::is_destructible<const Abstract>::value, "Error");
|
||||
static_assert(std::is_destructible<int[1]>::value, "Error");
|
||||
static_assert(std::is_destructible<const int[1]>::value, "Error");
|
||||
static_assert(std::is_destructible<int[1][2]>::value, "Error");
|
||||
static_assert(std::is_destructible<const int[1][2]>::value, "Error");
|
||||
static_assert(std::is_destructible<int&>::value, "Error");
|
||||
static_assert(std::is_destructible<int&&>::value, "Error");
|
||||
static_assert(std::is_destructible<void(&)()>::value, "Error");
|
||||
static_assert(std::is_destructible<Ellipsis>::value, "Error");
|
||||
static_assert(std::is_destructible<const Ellipsis>::value, "Error");
|
||||
static_assert(std::is_destructible<Any>::value, "Error");
|
||||
static_assert(std::is_destructible<const Any>::value, "Error");
|
||||
static_assert(std::is_destructible<nAny>::value, "Error");
|
||||
static_assert(std::is_destructible<const nAny>::value, "Error");
|
||||
static_assert(std::is_destructible<DelDef>::value, "Error");
|
||||
static_assert(std::is_destructible<const DelDef>::value, "Error");
|
||||
static_assert(std::is_destructible<DelCopy>::value, "Error");
|
||||
static_assert(std::is_destructible<const DelCopy>::value, "Error");
|
||||
static_assert(std::is_destructible<DelEllipsis>::value, "Error");
|
||||
static_assert(std::is_destructible<const DelEllipsis>::value, "Error");
|
||||
static_assert(std::is_destructible<std::initializer_list<int>>::value,
|
||||
"Error");
|
||||
static_assert(std::is_destructible<const std::initializer_list<int>>::value,
|
||||
"Error");
|
||||
static_assert(std::is_destructible<void()>::value, "Error");
|
||||
static_assert(std::is_destructible<void() const>::value, "Error");
|
||||
|
||||
static_assert(!std::is_destructible<void>::value, "Error");
|
||||
static_assert(!std::is_destructible<const void>::value, "Error");
|
||||
static_assert(!std::is_destructible<int[]>::value, "Error");
|
||||
static_assert(!std::is_destructible<const int[]>::value, "Error");
|
||||
static_assert(!std::is_destructible<DelDtor>::value, "Error");
|
||||
static_assert(!std::is_destructible<const DelDtor>::value, "Error");
|
||||
static_assert(!std::is_destructible<AbstractDelDtor>::value, "Error");
|
||||
static_assert(!std::is_destructible<const AbstractDelDtor>::value, "Error");
|
||||
static_assert(!std::is_destructible<int[][1]>::value, "Error");
|
||||
static_assert(!std::is_destructible<const int[][1]>::value, "Error");
|
||||
static_assert(!std::is_destructible<DelDtor[1]>::value, "Error");
|
||||
static_assert(!std::is_destructible<const DelDtor[1]>::value, "Error");
|
||||
static_assert(!std::is_destructible<DelDtor[]>::value, "Error");
|
||||
static_assert(!std::is_destructible<const DelDtor[]>::value, "Error");
|
||||
|
||||
// Deleted members in unions with non-trivial members:
|
||||
static_assert(!std::is_destructible<NontrivialUnion>::value, "Error");
|
||||
|
||||
// Unusual copy:
|
||||
static_assert(std::is_destructible<UnusualCopy>::value, "Error");
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
// libstdc++/24808
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_function;
|
||||
using namespace __gnu_test;
|
||||
|
||||
VERIFY( (test_category<is_function, IncompleteClass>(false)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
// { dg-options "-std=gnu++0x -pedantic-errors" }
|
||||
// { 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 <functional>
|
||||
|
||||
struct S
|
||||
{
|
||||
void F() const {}
|
||||
};
|
||||
|
||||
// libstdc++/35637
|
||||
void test01()
|
||||
{
|
||||
std::function<void (S *)> a(&S::F);
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_function<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_function<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_function;
|
||||
using namespace __gnu_test;
|
||||
|
||||
// Positive tests.
|
||||
VERIFY( (test_category<is_function, int (int)>(true)) );
|
||||
VERIFY( (test_category<is_function, ClassType (ClassType)>(true)) );
|
||||
VERIFY( (test_category<is_function, float (int, float, int[], int&)>(true)) );
|
||||
VERIFY( (test_category<is_function, int (int, ...)>(true)) );
|
||||
|
||||
// Negative tests.
|
||||
VERIFY( (test_category<is_function, int&>(false)) );
|
||||
VERIFY( (test_category<is_function, void>(false)) );
|
||||
VERIFY( (test_category<is_function, const void>(false)) );
|
||||
|
||||
VERIFY( (test_category<is_function, AbstractClass>(false)) );
|
||||
VERIFY( (test_category<is_function, int(&)(int)>(false)) );
|
||||
|
||||
// Sanity check.
|
||||
VERIFY( (test_category<is_function, ClassType>(false)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_fundamental<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_fundamental<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_fundamental;
|
||||
using namespace __gnu_test;
|
||||
|
||||
VERIFY( (test_category<is_fundamental, void>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, char>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, signed char>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, unsigned char>(true)) );
|
||||
#ifdef _GLIBCXX_USE_WCHAR_T
|
||||
VERIFY( (test_category<is_fundamental, wchar_t>(true)) );
|
||||
#endif
|
||||
VERIFY( (test_category<is_fundamental, short>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, unsigned short>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, int>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, unsigned int>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, long>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, unsigned long>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, long long>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, unsigned long long>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, float>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, double>(true)) );
|
||||
VERIFY( (test_category<is_fundamental, long double>(true)) );
|
||||
|
||||
// Sanity check.
|
||||
VERIFY( (test_category<is_fundamental, ClassType>(false)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_member_function_pointer<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_member_function_pointer<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_member_function_pointer;
|
||||
using namespace __gnu_test;
|
||||
|
||||
// Positive tests.
|
||||
VERIFY( (test_category<is_member_function_pointer,
|
||||
int (ClassType::*) (int)>(true)) );
|
||||
VERIFY( (test_category<is_member_function_pointer,
|
||||
int (ClassType::*) (int) const>(true)) );
|
||||
VERIFY( (test_category<is_member_function_pointer,
|
||||
int (ClassType::*) (float, ...)>(true)) );
|
||||
VERIFY( (test_category<is_member_function_pointer,
|
||||
ClassType (ClassType::*) (ClassType)>(true)) );
|
||||
VERIFY( (test_category<is_member_function_pointer,
|
||||
float (ClassType::*) (int, float, int[], int&)>(true)) );
|
||||
|
||||
// Negative tests.
|
||||
VERIFY( (test_category<is_member_function_pointer,
|
||||
int (ClassType::*)>(false)) );
|
||||
VERIFY( (test_category<is_member_function_pointer,
|
||||
const int (ClassType::*)>(false)) );
|
||||
VERIFY( (test_category<is_member_function_pointer,
|
||||
ClassType (ClassType::*)>(false)) );
|
||||
|
||||
// Sanity check.
|
||||
VERIFY( (test_category<is_member_function_pointer, ClassType>(false)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_member_object_pointer<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_member_object_pointer<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_member_object_pointer;
|
||||
using namespace __gnu_test;
|
||||
|
||||
// Positive tests.
|
||||
VERIFY( (test_category<is_member_object_pointer,
|
||||
int (ClassType::*)>(true)) );
|
||||
VERIFY( (test_category<is_member_object_pointer,
|
||||
const int (ClassType::*)>(true)) );
|
||||
VERIFY( (test_category<is_member_object_pointer,
|
||||
ClassType (ClassType::*)>(true)) );
|
||||
|
||||
// Negative tests.
|
||||
VERIFY( (test_category<is_member_object_pointer,
|
||||
int (ClassType::*) (int)>(false)) );
|
||||
VERIFY( (test_category<is_member_object_pointer,
|
||||
int (ClassType::*) (int) const>(false)) );
|
||||
VERIFY( (test_category<is_member_object_pointer,
|
||||
int (ClassType::*) (float, ...)>(false)) );
|
||||
VERIFY( (test_category<is_member_object_pointer,
|
||||
ClassType (ClassType::*) (ClassType)>(false)) );
|
||||
VERIFY( (test_category<is_member_object_pointer,
|
||||
float (ClassType::*) (int, float, int[], int&)>(false)) );
|
||||
|
||||
// Sanity check.
|
||||
VERIFY( (test_category<is_member_object_pointer, ClassType>(false)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_member_pointer<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_member_pointer<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_member_pointer;
|
||||
using namespace __gnu_test;
|
||||
|
||||
VERIFY( (test_category<is_member_pointer, int (ClassType::*)>(true)) );
|
||||
VERIFY( (test_category<is_member_pointer, const int (ClassType::*)>(true)) );
|
||||
VERIFY( (test_category<is_member_pointer, ClassType (ClassType::*)>(true)) );
|
||||
|
||||
VERIFY( (test_category<is_member_pointer,
|
||||
int (ClassType::*) (int)>(true)) );
|
||||
VERIFY( (test_category<is_member_pointer,
|
||||
int (ClassType::*) (int) const>(true)) );
|
||||
VERIFY( (test_category<is_member_pointer,
|
||||
int (ClassType::*) (float, ...)>(true)) );
|
||||
VERIFY( (test_category<is_member_pointer,
|
||||
ClassType (ClassType::*) (ClassType)>(true)) );
|
||||
VERIFY( (test_category<is_member_pointer,
|
||||
float (ClassType::*) (int, float, int[], int&)>(true)) );
|
||||
|
||||
// Sanity check.
|
||||
VERIFY( (test_category<is_member_pointer, ClassType>(false)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
// libstdc++/24808
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_object;
|
||||
using namespace __gnu_test;
|
||||
|
||||
VERIFY( (test_category<is_object, IncompleteClass>(true)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// { 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/>.
|
||||
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef short test_type;
|
||||
template struct is_object<test_type>;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
// { 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/>.
|
||||
|
||||
//
|
||||
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
// { dg-do compile }
|
||||
|
||||
void test01()
|
||||
{
|
||||
// Check for required typedefs
|
||||
typedef std::is_object<int> test_type;
|
||||
typedef test_type::value_type value_type;
|
||||
typedef test_type::type type;
|
||||
typedef test_type::type::value_type type_value_type;
|
||||
typedef test_type::type::type type_type;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
// { 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 <type_traits>
|
||||
#include <testsuite_hooks.h>
|
||||
#include <testsuite_tr1.h>
|
||||
|
||||
void test01()
|
||||
{
|
||||
bool test __attribute__((unused)) = true;
|
||||
using std::is_object;
|
||||
using namespace __gnu_test;
|
||||
|
||||
VERIFY( (test_category<is_object, int (int)>(false)) );
|
||||
VERIFY( (test_category<is_object, ClassType (ClassType)>(false)) );
|
||||
VERIFY( (test_category<is_object, float (int, float, int[], int&)>(false)) );
|
||||
VERIFY( (test_category<is_object, int&>(false)) );
|
||||
VERIFY( (test_category<is_object, ClassType&>(false)) );
|
||||
VERIFY( (test_category<is_object, int(&)(int)>(false)) );
|
||||
VERIFY( (test_category<is_object, void>(false)) );
|
||||
VERIFY( (test_category<is_object, const void>(false)) );
|
||||
|
||||
// Sanity check.
|
||||
VERIFY( (test_category<is_object, ClassType>(true)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -3,7 +3,7 @@
|
|||
|
||||
// 2007-05-03 Benjamin Kosnik <bkoz@redhat.com>
|
||||
//
|
||||
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
|
||||
// Copyright (C) 2007, 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
|
||||
|
|
@ -48,5 +48,5 @@ void test01()
|
|||
// { dg-error "instantiated from here" "" { target *-*-* } 40 }
|
||||
// { dg-error "instantiated from here" "" { target *-*-* } 42 }
|
||||
|
||||
// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1097 }
|
||||
// { dg-error "declaration of" "" { target *-*-* } 1061 }
|
||||
// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1302 }
|
||||
// { dg-error "declaration of" "" { target *-*-* } 1266 }
|
||||
|
|
|
|||
|
|
@ -48,5 +48,5 @@ void test01()
|
|||
// { dg-error "instantiated from here" "" { target *-*-* } 40 }
|
||||
// { dg-error "instantiated from here" "" { target *-*-* } 42 }
|
||||
|
||||
// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1020 }
|
||||
// { dg-error "declaration of" "" { target *-*-* } 984 }
|
||||
// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1226 }
|
||||
// { dg-error "declaration of" "" { target *-*-* } 1190 }
|
||||
|
|
|
|||
|
|
@ -51,4 +51,4 @@ test04()
|
|||
// { dg-error "instantiated from here" "" { target *-*-* } 46 }
|
||||
// { dg-error "denominator cannot be zero" "" { target *-*-* } 155 }
|
||||
// { dg-error "out of range" "" { target *-*-* } 156 }
|
||||
// { dg-error "overflow in constant expression" "" { target *-*-* } 74 }
|
||||
// { dg-error "overflow in constant expression" "" { target *-*-* } 99 }
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
// -*- C++ -*-
|
||||
// Testing utilities for the tr1 testsuite.
|
||||
//
|
||||
// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010
|
||||
// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011
|
||||
// Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
|
|
@ -283,6 +283,130 @@ namespace __gnu_test
|
|||
check_ret_type(T)
|
||||
{ return true; }
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
namespace construct_destruct
|
||||
{
|
||||
struct Empty {};
|
||||
|
||||
struct B { int i; B(){} };
|
||||
struct D : B {};
|
||||
|
||||
enum E { ee1 };
|
||||
enum E2 { ee2 };
|
||||
enum class SE { e1 };
|
||||
enum class SE2 { e2 };
|
||||
|
||||
enum OpE : int;
|
||||
enum class OpSE : bool;
|
||||
|
||||
union U { int i; Empty b; };
|
||||
|
||||
struct Abstract
|
||||
{
|
||||
virtual ~Abstract() = 0;
|
||||
};
|
||||
|
||||
struct AbstractDelDtor
|
||||
{
|
||||
~AbstractDelDtor() = delete;
|
||||
virtual void foo() = 0;
|
||||
};
|
||||
|
||||
struct Ukn;
|
||||
|
||||
template<class To>
|
||||
struct ImplicitTo
|
||||
{
|
||||
operator To();
|
||||
};
|
||||
|
||||
template<class To>
|
||||
struct DelImplicitTo
|
||||
{
|
||||
operator To() = delete;
|
||||
};
|
||||
|
||||
template<class To>
|
||||
struct ExplicitTo
|
||||
{
|
||||
explicit operator To();
|
||||
};
|
||||
|
||||
struct Ellipsis
|
||||
{
|
||||
Ellipsis(...){}
|
||||
};
|
||||
|
||||
struct DelEllipsis
|
||||
{
|
||||
DelEllipsis(...) = delete;
|
||||
};
|
||||
|
||||
struct Any
|
||||
{
|
||||
template<class T>
|
||||
Any(T&&){}
|
||||
};
|
||||
|
||||
struct nAny
|
||||
{
|
||||
template<class... T>
|
||||
nAny(T&&...){}
|
||||
};
|
||||
|
||||
struct DelnAny
|
||||
{
|
||||
template<class... T>
|
||||
DelnAny(T&&...) = delete;
|
||||
};
|
||||
|
||||
template<class... Args>
|
||||
struct FromArgs
|
||||
{
|
||||
FromArgs(Args...);
|
||||
};
|
||||
|
||||
struct DelDef
|
||||
{
|
||||
DelDef() = delete;
|
||||
};
|
||||
|
||||
struct DelCopy
|
||||
{
|
||||
DelCopy(const DelCopy&) = delete;
|
||||
};
|
||||
|
||||
struct DelDtor
|
||||
{
|
||||
DelDtor() = default;
|
||||
DelDtor(const DelDtor&) = default;
|
||||
DelDtor(DelDtor&&) = default;
|
||||
DelDtor(int);
|
||||
DelDtor(int, B, U);
|
||||
~DelDtor() = delete;
|
||||
};
|
||||
|
||||
struct Nontrivial
|
||||
{
|
||||
Nontrivial();
|
||||
Nontrivial(const Nontrivial&);
|
||||
Nontrivial& operator=(const Nontrivial&);
|
||||
~Nontrivial();
|
||||
};
|
||||
|
||||
union NontrivialUnion
|
||||
{
|
||||
int i;
|
||||
Nontrivial n;
|
||||
};
|
||||
|
||||
struct UnusualCopy
|
||||
{
|
||||
UnusualCopy(UnusualCopy&);
|
||||
};
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace __gnu_test
|
||||
|
||||
#endif // _GLIBCXX_TESTSUITE_TR1_H
|
||||
|
|
|
|||
Loading…
Reference in New Issue