// -*- C++ -*-
// Testing utilities for the tr1 testsuite.
//
-// Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2004-2020 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 2, or (at your option)
+// 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,
// 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 COPYING. If not, write to the Free
-// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-// USA.
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
//
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
#ifndef _GLIBCXX_TESTSUITE_TR1_H
#define _GLIBCXX_TESTSUITE_TR1_H
#include <ext/type_traits.h>
+#include <testsuite_hooks.h>
namespace __gnu_test
{
// For tr1/type_traits.
template<template<typename> class Category, typename Type>
+#if __cplusplus >= 201103L
+ constexpr
+#endif
bool
test_category(bool value)
{
- bool ret = true;
- ret &= Category<Type>::value == value;
- ret &= Category<const Type>::value == value;
- ret &= Category<volatile Type>::value == value;
- ret &= Category<const volatile Type>::value == value;
- ret &= Category<Type>::type::value == value;
- ret &= Category<const Type>::type::value == value;
- ret &= Category<volatile Type>::type::value == value;
- ret &= Category<const volatile Type>::type::value == value;
- return ret;
- }
-
- template<template<typename> class Property, typename Type>
- bool
- test_property(typename Property<Type>::value_type value)
- {
- bool ret = true;
- ret &= Property<Type>::value == value;
- ret &= Property<Type>::type::value == value;
- return ret;
+ return (Category<Type>::value == value
+ && Category<const Type>::value == value
+ && Category<volatile Type>::value == value
+ && Category<const volatile Type>::value == value
+ && Category<Type>::type::value == value
+ && Category<const Type>::type::value == value
+ && Category<volatile Type>::type::value == value
+ && Category<const volatile Type>::type::value == value);
}
// For testing tr1/type_traits/extent, which has a second template
// parameter.
template<template<typename, unsigned> class Property,
- typename Type,
- unsigned Uint>
+ typename Type, unsigned Uint>
+#if __cplusplus >= 201103L
+ constexpr
+#endif
bool
test_property(typename Property<Type, Uint>::value_type value)
{
- bool ret = true;
- ret &= Property<Type, Uint>::value == value;
- ret &= Property<Type, Uint>::type::value == value;
- return ret;
+ return (Property<Type, Uint>::value == value
+ && Property<Type, Uint>::type::value == value);
+ }
+
+#if __cplusplus >= 201103L
+ template<template<typename...> class Property,
+ typename Type1, typename... Types>
+ constexpr bool
+ test_property(typename Property<Type1, Types...>::value_type value)
+ {
+ return (Property<Type1, Types...>::value == value
+ && Property<Type1, Types...>::type::value == value);
+ }
+#else
+ template<template<typename> class Property, typename Type>
+ bool
+ test_property(typename Property<Type>::value_type value)
+ {
+ return (Property<Type>::value == value
+ && Property<Type>::type::value == value);
}
+#endif
template<template<typename, typename> class Relationship,
- typename Type1, typename Type2>
+ typename Type1, typename Type2>
+#if __cplusplus >= 201103L
+ constexpr
+#endif
bool
test_relationship(bool value)
{
- bool ret = true;
- ret &= Relationship<Type1, Type2>::value == value;
- ret &= Relationship<Type1, Type2>::type::value == value;
- return ret;
+ return (Relationship<Type1, Type2>::value == value
+ && Relationship<Type1, Type2>::type::value == value);
}
// Test types.
class DerivedType : public ClassType { };
- enum EnumType { };
+#if __cplusplus >= 201103L
+ class FinalType final : public DerivedType { };
+#endif
+
+ enum EnumType { e0 };
struct ConvType
{ operator int() const; };
class AbstractClass
{
virtual void rotate(int) = 0;
- virtual ~AbstractClass();
};
class PolymorphicClass
{
virtual void rotate(int);
- virtual ~PolymorphicClass();
};
class DerivedPolymorphic : public PolymorphicClass { };
+ class VirtualDestructorClass
+ {
+ virtual ~VirtualDestructorClass();
+ };
+
union UnionType { };
+ union IncompleteUnion;
+
class IncompleteClass;
+ struct ExplicitClass
+ {
+ ExplicitClass(double&);
+ explicit ExplicitClass(int&);
+ ExplicitClass(double&, int&, double&);
+ };
+
+ struct NothrowExplicitClass
+ {
+ NothrowExplicitClass(double&) throw();
+ explicit NothrowExplicitClass(int&) throw();
+ NothrowExplicitClass(double&, int&, double&) throw();
+ };
+
+ struct ThrowExplicitClass
+ {
+ ThrowExplicitClass(double&) THROW(int);
+ explicit ThrowExplicitClass(int&) THROW(int);
+ ThrowExplicitClass(double&, int&, double&) THROW(int);
+ };
+
+ struct ThrowDefaultClass
+ {
+ ThrowDefaultClass() THROW(int);
+ };
+
+ struct ThrowCopyConsClass
+ {
+ ThrowCopyConsClass(const ThrowCopyConsClass&) THROW(int);
+ };
+
+#if __cplusplus >= 201103L
+ struct ThrowMoveConsClass
+ {
+ ThrowMoveConsClass(ThrowMoveConsClass&&) noexcept(false);
+ };
+
+ struct NoexceptExplicitClass
+ {
+ NoexceptExplicitClass(double&) noexcept(true);
+ explicit NoexceptExplicitClass(int&) noexcept(true);
+ NoexceptExplicitClass(double&, int&, double&) noexcept(true);
+ };
+
+ struct ExceptExplicitClass
+ {
+ ExceptExplicitClass(double&) noexcept(false);
+ explicit ExceptExplicitClass(int&) noexcept(false);
+ ExceptExplicitClass(double&, int&, double&) noexcept(false);
+ };
+
+ struct NoexceptDefaultClass
+ {
+ NoexceptDefaultClass() noexcept(true);
+ };
+
+ struct ExceptDefaultClass
+ {
+ ExceptDefaultClass() noexcept(false);
+ };
+
+ struct NoexceptCopyConsClass
+ {
+ NoexceptCopyConsClass(const NoexceptCopyConsClass&) noexcept(true);
+ };
+
+ struct ExceptCopyConsClass
+ {
+ ExceptCopyConsClass(const ExceptCopyConsClass&) noexcept(false);
+ };
+
+ struct NoexceptMoveConsClass
+ {
+ NoexceptMoveConsClass(NoexceptMoveConsClass&&) noexcept(true);
+ NoexceptMoveConsClass& operator=(NoexceptMoveConsClass&&) = default;
+ };
+
+ struct ExceptMoveConsClass
+ {
+ ExceptMoveConsClass(ExceptMoveConsClass&&) noexcept(false);
+ };
+
+ struct NoexceptCopyAssignClass
+ {
+ NoexceptCopyAssignClass&
+ operator=(const NoexceptCopyAssignClass&) noexcept(true);
+ };
+
+ struct ExceptCopyAssignClass
+ {
+ ExceptCopyAssignClass&
+ operator=(const ExceptCopyAssignClass&) noexcept(false);
+ };
+
+ struct NoexceptMoveAssignClass
+ {
+ NoexceptMoveAssignClass(NoexceptMoveAssignClass&&) = default;
+ NoexceptMoveAssignClass&
+ operator=(NoexceptMoveAssignClass&&) noexcept(true);
+ };
+
+ struct ExceptMoveAssignClass
+ {
+ ExceptMoveAssignClass&
+ operator=(ExceptMoveAssignClass&&) noexcept(false);
+ };
+
+ struct DeletedCopyAssignClass
+ {
+ DeletedCopyAssignClass&
+ operator=(const DeletedCopyAssignClass&) = delete;
+ };
+
+ struct DeletedMoveAssignClass
+ {
+ DeletedMoveAssignClass&
+ operator=(DeletedMoveAssignClass&&) = delete;
+ };
+
+ struct NoexceptMoveConsNoexceptMoveAssignClass
+ {
+ NoexceptMoveConsNoexceptMoveAssignClass
+ (NoexceptMoveConsNoexceptMoveAssignClass&&) noexcept(true);
+
+ NoexceptMoveConsNoexceptMoveAssignClass&
+ operator=(NoexceptMoveConsNoexceptMoveAssignClass&&) noexcept(true);
+ };
+
+ struct ExceptMoveConsNoexceptMoveAssignClass
+ {
+ ExceptMoveConsNoexceptMoveAssignClass
+ (ExceptMoveConsNoexceptMoveAssignClass&&) noexcept(false);
+
+ ExceptMoveConsNoexceptMoveAssignClass&
+ operator=(ExceptMoveConsNoexceptMoveAssignClass&&) noexcept(true);
+ };
+
+ struct NoexceptMoveConsExceptMoveAssignClass
+ {
+ NoexceptMoveConsExceptMoveAssignClass
+ (NoexceptMoveConsExceptMoveAssignClass&&) noexcept(true);
+
+ NoexceptMoveConsExceptMoveAssignClass&
+ operator=(NoexceptMoveConsExceptMoveAssignClass&&) noexcept(false);
+ };
+
+ struct ExceptMoveConsExceptMoveAssignClass
+ {
+ ExceptMoveConsExceptMoveAssignClass
+ (ExceptMoveConsExceptMoveAssignClass&&) noexcept(false);
+
+ ExceptMoveConsExceptMoveAssignClass&
+ operator=(ExceptMoveConsExceptMoveAssignClass&&) noexcept(false);
+ };
+#endif
+
+ struct NType // neither trivial nor standard-layout
+ {
+ int i;
+ int j;
+ virtual ~NType();
+ };
+
+ struct TType // trivial but not standard-layout
+ {
+ int i;
+ private:
+ int j;
+ };
+
+ struct SLType // standard-layout but not trivial
+ {
+ int i;
+ int j;
+ ~SLType();
+ };
+
+ struct PODType // both trivial and standard-layout
+ {
+ int i;
+ int j;
+ };
+
+#if __cplusplus >= 201103L
+ struct LType // literal type
+ {
+ int _M_i;
+
+ constexpr LType(int __i) : _M_i(__i) { }
+ };
+
+ struct LTypeDerived : public LType
+ {
+ constexpr LTypeDerived(int __i) : LType(__i) { }
+ };
+
+ struct NLType // not literal type
+ {
+ int _M_i;
+
+ NLType() : _M_i(0) { }
+
+ constexpr NLType(int __i) : _M_i(__i) { }
+
+ NLType(const NLType& __other) : _M_i(__other._M_i) { }
+
+ ~NLType() { _M_i = 0; }
+ };
+#endif
+
int truncate_float(float x) { return (int)x; }
long truncate_double(double x) { return (long)x; }
// For use in 8_c_compatibility.
template<typename R, typename T>
- typename __gnu_cxx::__enable_if<std::tr1::is_same<R, T>::value,
+ typename __gnu_cxx::__enable_if<std::__are_same<R, T>::__value,
bool>::__type
check_ret_type(T)
{ return true; }
+#if __cplusplus >= 201103L
+ namespace construct
+ {
+ 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&);
+ };
+ }
+
+ namespace destruct
+ {
+ struct E
+ {};
+
+ struct NTD1
+ {
+ ~NTD1() = default;
+ };
+
+ struct NTD2
+ {
+ ~NTD2();
+ };
+
+ struct NTD3
+ {
+ ~NTD3() throw();
+ };
+
+ struct TD1
+ {
+ ~TD1() noexcept(false);
+ };
+
+ struct TD2
+ {
+ ~TD2() THROW(int);
+ };
+
+ struct Aggr
+ {
+ int i;
+ bool b;
+ E e;
+ };
+
+ struct Aggr2
+ {
+ int i;
+ bool b;
+ TD1 r;
+ };
+
+ struct Del
+ {
+ ~Del() = delete;
+ };
+
+ struct Del2
+ {
+ ~Del2() noexcept = delete;
+ };
+
+ struct Del3
+ {
+ ~Del3() noexcept(false) = delete;
+ };
+
+ struct Der : Aggr
+ {};
+
+ struct Der2 : Aggr2
+ {};
+
+ union U1
+ {
+ int i;
+ double d;
+ void* p;
+ TD1* pt;
+ };
+
+ union Ut
+ {
+ int i;
+ double d;
+ void* p;
+ TD1 pt;
+ };
+
+ enum class En { a, b, c, d };
+ enum En2 { En2a, En2b, En2c, En2d };
+
+ enum OpE : int;
+ enum class OpSE : bool;
+
+ struct Abstract1
+ {
+ virtual ~Abstract1() = 0;
+ };
+
+ struct AbstractDelDtor
+ {
+ ~AbstractDelDtor() = delete;
+ virtual void foo() = 0;
+ };
+
+ struct Abstract2
+ {
+ virtual ~Abstract2() noexcept(false) = 0;
+ };
+
+ struct Abstract3
+ {
+ ~Abstract3() noexcept(false);
+ virtual void foo() noexcept = 0;
+ };
+
+ struct Nontrivial
+ {
+ Nontrivial();
+ Nontrivial(const Nontrivial&);
+ Nontrivial& operator=(const Nontrivial&);
+ ~Nontrivial();
+ };
+
+ union NontrivialUnion
+ {
+ int i;
+ Nontrivial n;
+ };
+
+ struct UnusualCopy
+ {
+ UnusualCopy(UnusualCopy&);
+ };
+
+ struct Ellipsis
+ {
+ Ellipsis(...){}
+ };
+
+ struct DelEllipsis
+ {
+ DelEllipsis(...) = delete;
+ };
+
+ struct DelDef
+ {
+ DelDef() = delete;
+ };
+
+ struct DelCopy
+ {
+ DelCopy(const DelCopy&) = delete;
+ };
+ }
+
+ namespace assign
+ {
+ 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; };
+
+ union UAssignAll
+ {
+ bool b;
+ char c;
+ template<class T>
+ void operator=(T&&);
+ };
+
+ union UDelAssignAll
+ {
+ bool b;
+ char c;
+ template<class T>
+ void operator=(T&&) = delete;
+ };
+
+ 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 ExplicitTo
+ {
+ explicit operator To();
+ };
+
+ template<class To>
+ struct DelImplicitTo
+ {
+ operator To() = delete;
+ };
+
+ template<class To>
+ struct DelExplicitTo
+ {
+ explicit operator To() = delete;
+ };
+
+ 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...);
+ };
+
+ template<class... Args>
+ struct DelFromArgs
+ {
+ DelFromArgs(Args...) = delete;
+ };
+
+ 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&);
+ };
+
+ struct AnyAssign
+ {
+ template<class T>
+ void operator=(T&&);
+ };
+
+ struct DelAnyAssign
+ {
+ template<class T>
+ void operator=(T&&) = delete;
+ };
+
+ struct DelCopyAssign
+ {
+ DelCopyAssign& operator=(const DelCopyAssign&) = delete;
+ DelCopyAssign& operator=(DelCopyAssign&&) = default;
+ };
+
+ struct MO
+ {
+ MO(MO&&) = default;
+ MO& operator=(MO&&) = default;
+ };
+ }
+
+ struct CopyConsOnlyType
+ {
+ CopyConsOnlyType(int) { }
+ CopyConsOnlyType(CopyConsOnlyType&&) = delete;
+ CopyConsOnlyType(const CopyConsOnlyType&) = default;
+ CopyConsOnlyType& operator=(const CopyConsOnlyType&) = delete;
+ CopyConsOnlyType& operator=(CopyConsOnlyType&&) = delete;
+ };
+
+ struct MoveConsOnlyType
+ {
+ MoveConsOnlyType(int) { }
+ MoveConsOnlyType(const MoveConsOnlyType&) = delete;
+ MoveConsOnlyType(MoveConsOnlyType&&) = default;
+ MoveConsOnlyType& operator=(const MoveConsOnlyType&) = delete;
+ MoveConsOnlyType& operator=(MoveConsOnlyType&&) = delete;
+ };
+#endif
+
} // namespace __gnu_test
#endif // _GLIBCXX_TESTSUITE_TR1_H