mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-08 05:54:40 +00:00
895 lines
22 KiB
C++
895 lines
22 KiB
C++
// -*- C++ -*-
|
|
// typelist for the C++ library testsuite.
|
|
//
|
|
// Copyright (C) 2005-2016 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/>.
|
|
//
|
|
|
|
#ifndef _TESTSUITE_COMMON_TYPES_H
|
|
#define _TESTSUITE_COMMON_TYPES_H 1
|
|
|
|
#include <ext/typelist.h>
|
|
|
|
#include <ext/new_allocator.h>
|
|
#include <ext/malloc_allocator.h>
|
|
#include <ext/mt_allocator.h>
|
|
#include <ext/bitmap_allocator.h>
|
|
#include <ext/pool_allocator.h>
|
|
|
|
#include <algorithm>
|
|
|
|
#include <vector>
|
|
#include <list>
|
|
#include <deque>
|
|
#include <string>
|
|
#include <limits>
|
|
|
|
#include <map>
|
|
#include <set>
|
|
#include <tr1/functional>
|
|
#include <tr1/unordered_map>
|
|
#include <tr1/unordered_set>
|
|
|
|
#if __cplusplus >= 201103L
|
|
#include <atomic>
|
|
#include <type_traits>
|
|
#endif
|
|
|
|
namespace __gnu_test
|
|
{
|
|
using __gnu_cxx::typelist::node;
|
|
using __gnu_cxx::typelist::transform;
|
|
using __gnu_cxx::typelist::append;
|
|
|
|
// All the allocators to test.
|
|
template<typename Tp, bool Thread>
|
|
struct allocator_policies
|
|
{
|
|
typedef Tp value_type;
|
|
typedef __gnu_cxx::new_allocator<Tp> a1;
|
|
typedef __gnu_cxx::malloc_allocator<Tp> a2;
|
|
typedef __gnu_cxx::__common_pool_policy<__gnu_cxx::__pool, Thread> pool_policy;
|
|
typedef __gnu_cxx::__mt_alloc<Tp, pool_policy> a3;
|
|
typedef __gnu_cxx::bitmap_allocator<Tp> a4;
|
|
typedef __gnu_cxx::__pool_alloc<Tp> a5;
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN5(a1, a2, a3, a4, a5)> type;
|
|
};
|
|
|
|
// Typelists for vector, string, list, deque.
|
|
// XXX should just use template templates
|
|
template<typename Tp, bool Thread>
|
|
struct vectors
|
|
{
|
|
typedef Tp value_type;
|
|
|
|
template<typename Tl>
|
|
struct vector_shell
|
|
{
|
|
typedef Tl allocator_type;
|
|
typedef std::vector<value_type, allocator_type> type;
|
|
};
|
|
|
|
typedef allocator_policies<value_type, Thread> allocator_types;
|
|
typedef typename allocator_types::type allocator_typelist;
|
|
typedef typename transform<allocator_typelist, vector_shell>::type type;
|
|
};
|
|
|
|
template<typename Tp, bool Thread>
|
|
struct lists
|
|
{
|
|
typedef Tp value_type;
|
|
|
|
template<typename Tl>
|
|
struct list_shell
|
|
{
|
|
typedef Tl allocator_type;
|
|
typedef std::list<value_type, allocator_type> type;
|
|
};
|
|
|
|
typedef allocator_policies<value_type, Thread> allocator_types;
|
|
typedef typename allocator_types::type allocator_typelist;
|
|
typedef typename transform<allocator_typelist, list_shell>::type type;
|
|
};
|
|
|
|
template<typename Tp, bool Thread>
|
|
struct deques
|
|
{
|
|
typedef Tp value_type;
|
|
|
|
template<typename Tl>
|
|
struct deque_shell
|
|
{
|
|
typedef Tl allocator_type;
|
|
typedef std::deque<value_type, allocator_type> type;
|
|
};
|
|
|
|
typedef allocator_policies<value_type, Thread> allocator_types;
|
|
typedef typename allocator_types::type allocator_typelist;
|
|
typedef typename transform<allocator_typelist, deque_shell>::type type;
|
|
};
|
|
|
|
template<typename Tp, bool Thread>
|
|
struct strings
|
|
{
|
|
typedef Tp value_type;
|
|
|
|
template<typename Tl>
|
|
struct string_shell
|
|
{
|
|
typedef Tl allocator_type;
|
|
typedef std::char_traits<value_type> traits_type;
|
|
typedef std::basic_string<value_type, traits_type, allocator_type> type;
|
|
};
|
|
|
|
typedef allocator_policies<value_type, Thread> allocator_types;
|
|
typedef typename allocator_types::type allocator_typelist;
|
|
typedef typename transform<allocator_typelist, string_shell>::type type;
|
|
};
|
|
|
|
// A typelist of vector, list, deque, and string all instantiated
|
|
// with each of the allocator policies.
|
|
template<typename Tp, bool Thread>
|
|
struct sequence_containers
|
|
{
|
|
typedef Tp value_type;
|
|
|
|
typedef typename vectors<value_type, Thread>::type vector_typelist;
|
|
typedef typename lists<value_type, Thread>::type list_typelist;
|
|
typedef typename deques<value_type, Thread>::type deque_typelist;
|
|
typedef typename strings<value_type, Thread>::type string_typelist;
|
|
|
|
typedef typename append<vector_typelist, list_typelist>::type a1;
|
|
typedef typename append<deque_typelist, string_typelist>::type a2;
|
|
typedef typename append<a1, a2>::type type;
|
|
};
|
|
|
|
// Typelists for map, set, unordered_set, unordered_map.
|
|
template<typename Tp, bool Thread>
|
|
struct maps
|
|
{
|
|
typedef Tp value_type;
|
|
typedef Tp key_type;
|
|
typedef std::pair<const key_type, value_type> pair_type;
|
|
typedef std::less<key_type> compare_function;
|
|
|
|
template<typename Tl>
|
|
struct container
|
|
{
|
|
typedef Tl allocator_type;
|
|
typedef std::map<key_type, value_type, compare_function, allocator_type> type;
|
|
};
|
|
|
|
typedef allocator_policies<pair_type, Thread> allocator_types;
|
|
typedef typename allocator_types::type allocator_typelist;
|
|
typedef typename transform<allocator_typelist, container>::type type;
|
|
};
|
|
|
|
template<typename Tp, bool Thread>
|
|
struct unordered_maps
|
|
{
|
|
typedef Tp value_type;
|
|
typedef Tp key_type;
|
|
typedef std::pair<const key_type, value_type> pair_type;
|
|
typedef std::tr1::hash<key_type> hash_function;
|
|
typedef std::equal_to<key_type> equality_function;
|
|
|
|
template<typename Tl>
|
|
struct container
|
|
{
|
|
typedef Tl allocator_type;
|
|
typedef std::tr1::unordered_map<key_type, value_type, hash_function, equality_function, allocator_type> type;
|
|
};
|
|
|
|
typedef allocator_policies<pair_type, Thread> allocator_types;
|
|
typedef typename allocator_types::type allocator_typelist;
|
|
typedef typename transform<allocator_typelist, container>::type type;
|
|
};
|
|
|
|
template<typename Tp, bool Thread>
|
|
struct sets
|
|
{
|
|
typedef Tp value_type;
|
|
typedef Tp key_type;
|
|
typedef std::less<key_type> compare_function;
|
|
|
|
template<typename Tl>
|
|
struct container
|
|
{
|
|
typedef Tl allocator_type;
|
|
typedef std::set<key_type, compare_function, allocator_type> type;
|
|
};
|
|
|
|
typedef allocator_policies<key_type, Thread> allocator_types;
|
|
typedef typename allocator_types::type allocator_typelist;
|
|
typedef typename transform<allocator_typelist, container>::type type;
|
|
};
|
|
|
|
template<typename Tp, bool Thread>
|
|
struct unordered_sets
|
|
{
|
|
typedef Tp value_type;
|
|
typedef Tp key_type;
|
|
typedef std::tr1::hash<key_type> hash_function;
|
|
typedef std::equal_to<key_type> equality_function;
|
|
|
|
template<typename Tl>
|
|
struct container
|
|
{
|
|
typedef Tl allocator_type;
|
|
typedef std::tr1::unordered_set<key_type, hash_function, equality_function, allocator_type> type;
|
|
};
|
|
|
|
typedef allocator_policies<key_type, Thread> allocator_types;
|
|
typedef typename allocator_types::type allocator_typelist;
|
|
typedef typename transform<allocator_typelist, container>::type type;
|
|
};
|
|
|
|
|
|
// A typelist of all associated container types, with each of the
|
|
// allocator policies.
|
|
template<typename Tp, bool Thread>
|
|
struct associative_containers
|
|
{
|
|
typedef Tp value_type;
|
|
|
|
typedef typename maps<value_type, Thread>::type map_typelist;
|
|
typedef typename sets<value_type, Thread>::type set_typelist;
|
|
typedef typename unordered_maps<value_type, Thread>::type unordered_map_typelist;
|
|
typedef typename unordered_sets<value_type, Thread>::type unordered_set_typelist;
|
|
|
|
typedef typename append<map_typelist, unordered_map_typelist>::type a1;
|
|
typedef typename append<set_typelist, unordered_set_typelist>::type a2;
|
|
typedef typename append<a1, a2>::type type;
|
|
};
|
|
|
|
// A typelist of all standard integral types.
|
|
struct integral_types
|
|
{
|
|
typedef bool a1;
|
|
typedef char a2;
|
|
typedef signed char a3;
|
|
typedef unsigned char a4;
|
|
typedef short a5;
|
|
typedef unsigned short a6;
|
|
typedef int a7;
|
|
typedef unsigned int a8;
|
|
typedef long a9;
|
|
typedef unsigned long a10;
|
|
typedef long long a11;
|
|
typedef unsigned long long a12;
|
|
typedef wchar_t a13;
|
|
#if __cplusplus >= 201103L
|
|
typedef char16_t a14;
|
|
typedef char32_t a15;
|
|
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13, a14, a15)> type;
|
|
#else
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13)> type;
|
|
#endif
|
|
};
|
|
|
|
// A typelist of all standard integral types + the GNU 128-bit types.
|
|
struct integral_types_gnu
|
|
{
|
|
typedef bool a1;
|
|
typedef char a2;
|
|
typedef signed char a3;
|
|
typedef unsigned char a4;
|
|
typedef short a5;
|
|
typedef unsigned short a6;
|
|
typedef int a7;
|
|
typedef unsigned int a8;
|
|
typedef long a9;
|
|
typedef unsigned long a10;
|
|
typedef long long a11;
|
|
typedef unsigned long long a12;
|
|
typedef wchar_t a13;
|
|
#if __cplusplus >= 201103L
|
|
typedef char16_t a14;
|
|
typedef char32_t a15;
|
|
# if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
|
|
typedef __int128 a16;
|
|
typedef unsigned __int128 a17;
|
|
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN17(a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13, a14, a15,
|
|
a16, a17)> type;
|
|
# else
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13, a14, a15)> type;
|
|
# endif
|
|
#else
|
|
# if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
|
|
typedef __int128 a14;
|
|
typedef unsigned __int128 a15;
|
|
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13, a14, a15)> type;
|
|
# else
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13)> type;
|
|
# endif
|
|
#endif
|
|
};
|
|
|
|
#if __cplusplus >= 201103L
|
|
struct atomic_integrals_no_bool
|
|
{
|
|
typedef std::atomic_char a2;
|
|
typedef std::atomic_schar a3;
|
|
typedef std::atomic_uchar a4;
|
|
typedef std::atomic_short a5;
|
|
typedef std::atomic_ushort a6;
|
|
typedef std::atomic_int a7;
|
|
typedef std::atomic_uint a8;
|
|
typedef std::atomic_long a9;
|
|
typedef std::atomic_ulong a10;
|
|
typedef std::atomic_llong a11;
|
|
typedef std::atomic_ullong a12;
|
|
typedef std::atomic_wchar_t a13;
|
|
typedef std::atomic_char16_t a14;
|
|
typedef std::atomic_char32_t a15;
|
|
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN14(a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13, a14, a15)> type;
|
|
};
|
|
|
|
struct atomic_integrals
|
|
{
|
|
typedef std::atomic_bool a1;
|
|
typedef std::atomic_char a2;
|
|
typedef std::atomic_schar a3;
|
|
typedef std::atomic_uchar a4;
|
|
typedef std::atomic_short a5;
|
|
typedef std::atomic_ushort a6;
|
|
typedef std::atomic_int a7;
|
|
typedef std::atomic_uint a8;
|
|
typedef std::atomic_long a9;
|
|
typedef std::atomic_ulong a10;
|
|
typedef std::atomic_llong a11;
|
|
typedef std::atomic_ullong a12;
|
|
typedef std::atomic_wchar_t a13;
|
|
typedef std::atomic_char16_t a14;
|
|
typedef std::atomic_char32_t a15;
|
|
|
|
typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13, a14, a15)> type;
|
|
};
|
|
|
|
|
|
template<typename Tp>
|
|
struct atomics
|
|
{
|
|
typedef Tp value_type;
|
|
typedef std::atomic<value_type> type;
|
|
};
|
|
|
|
typedef transform<integral_types::type, atomics>::type atomics_tl;
|
|
#endif
|
|
|
|
template<typename Tp>
|
|
struct numeric_limits
|
|
{
|
|
typedef Tp value_type;
|
|
typedef std::numeric_limits<value_type> type;
|
|
};
|
|
|
|
typedef transform<integral_types_gnu::type, numeric_limits>::type limits_tl;
|
|
|
|
struct has_increment_operators
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
_Tp a;
|
|
++a; // prefix
|
|
a++; // postfix
|
|
a += a;
|
|
}
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
struct has_decrement_operators
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
_Tp a;
|
|
--a; // prefix
|
|
a--; // postfix
|
|
a -= a;
|
|
}
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
#if __cplusplus >= 201103L
|
|
template<typename _Tp>
|
|
void
|
|
constexpr_bitwise_operators()
|
|
{
|
|
constexpr _Tp a = _Tp();
|
|
constexpr _Tp b = _Tp();
|
|
constexpr _Tp c1 __attribute__((unused)) = a | b;
|
|
constexpr _Tp c2 __attribute__((unused)) = a & b;
|
|
constexpr _Tp c3 __attribute__((unused)) = a ^ b;
|
|
constexpr _Tp c4 __attribute__((unused)) = ~b;
|
|
}
|
|
#endif
|
|
|
|
template<typename _Tp>
|
|
void
|
|
bitwise_operators()
|
|
{
|
|
_Tp a = _Tp();
|
|
_Tp b = _Tp();
|
|
a | b;
|
|
a & b;
|
|
a ^ b;
|
|
~b;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
void
|
|
bitwise_assignment_operators()
|
|
{
|
|
_Tp a = _Tp();
|
|
_Tp b = _Tp();
|
|
a |= b; // set
|
|
a &= ~b; // clear
|
|
a ^= b;
|
|
}
|
|
|
|
// 17.3.2.1.2 - Bitmask types [lib.bitmask.types]
|
|
// bitmask_operators
|
|
template<typename _BitmTp>
|
|
void
|
|
bitmask_operators()
|
|
{
|
|
bitwise_operators<_BitmTp>();
|
|
bitwise_assignment_operators<_BitmTp>();
|
|
}
|
|
|
|
struct has_bitwise_operators
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
a |= b; // set
|
|
a &= ~b; // clear
|
|
a ^= b;
|
|
}
|
|
_Tp a;
|
|
_Tp b;
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
#if __cplusplus >= 201103L
|
|
|
|
struct constexpr_comparison_eq_ne
|
|
{
|
|
template<typename _Tp1, typename _Tp2 = _Tp1>
|
|
void
|
|
operator()()
|
|
{
|
|
static_assert(_Tp1() == _Tp2(), "eq");
|
|
static_assert(!(_Tp1() != _Tp2()), "ne");
|
|
}
|
|
};
|
|
|
|
struct constexpr_comparison_operators
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
static_assert(!(_Tp() < _Tp()), "less");
|
|
static_assert(_Tp() <= _Tp(), "leq");
|
|
static_assert(!(_Tp() > _Tp()), "more");
|
|
static_assert(_Tp() >= _Tp(), "meq");
|
|
static_assert(_Tp() == _Tp(), "eq");
|
|
static_assert(!(_Tp() != _Tp()), "ne");
|
|
}
|
|
};
|
|
|
|
// Generator to test standard layout
|
|
struct has_trivial_cons_dtor
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
typedef std::is_trivially_default_constructible<_Tp> ctor_p;
|
|
static_assert(ctor_p::value, "default constructor not trivial");
|
|
|
|
typedef std::is_trivially_destructible<_Tp> dtor_p;
|
|
static_assert(dtor_p::value, "destructor not trivial");
|
|
}
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
struct standard_layout
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
typedef std::is_standard_layout<_Tp> standard_layout_p;
|
|
static_assert(standard_layout_p::value, "not standard_layout");
|
|
}
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
#endif
|
|
|
|
// Generator to test base class
|
|
struct has_required_base_class
|
|
{
|
|
template<typename _TBase, typename _TDerived>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
const _TDerived& obj = __a;
|
|
const _TBase* base __attribute__((unused)) = &obj;
|
|
}
|
|
|
|
_TDerived __a;
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
// Generator to test assignment operator.
|
|
struct assignable
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{ __v1 = __v2; }
|
|
|
|
_Tp __v1;
|
|
_Tp __v2;
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
// Generator to test default constructor.
|
|
struct default_constructible
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{ _Tp __v __attribute__((unused)); }
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
// Generator to test copy constructor.
|
|
struct copy_constructible
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{ _Tp __v2(__v1); }
|
|
|
|
_Tp __v1;
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
// Generator to test direct initialization, single value constructor.
|
|
struct single_value_constructible
|
|
{
|
|
template<typename _Ttype, typename _Tvalue>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{ _Ttype __v(__a); }
|
|
|
|
_Tvalue __a;
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
#if __cplusplus >= 201103L
|
|
// Generator to test default constructor.
|
|
struct constexpr_default_constructible
|
|
{
|
|
template<typename _Tp, bool _IsLitp = std::is_literal_type<_Tp>::value>
|
|
struct _Concept;
|
|
|
|
// NB: _Tp must be a literal type.
|
|
// Have to have user-defined default ctor for this to work,
|
|
// or implicit default ctor must initialize all members.
|
|
template<typename _Tp>
|
|
struct _Concept<_Tp, true>
|
|
{
|
|
void __constraint()
|
|
{ constexpr _Tp __obj; }
|
|
};
|
|
|
|
// Non-literal type, declare local static and verify no
|
|
// constructors generated for _Tp within the translation unit.
|
|
template<typename _Tp>
|
|
struct _Concept<_Tp, false>
|
|
{
|
|
void __constraint()
|
|
{ static _Tp __obj; }
|
|
};
|
|
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
_Concept<_Tp> c;
|
|
c.__constraint();
|
|
}
|
|
};
|
|
|
|
// Generator to test defaulted default constructor.
|
|
struct constexpr_defaulted_default_constructible
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{ constexpr _Tp __v __attribute__((unused)) { }; }
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
struct constexpr_single_value_constructible
|
|
{
|
|
template<typename _Ttesttype, typename _Tvaluetype,
|
|
bool _IsLitp = std::is_literal_type<_Ttesttype>::value>
|
|
struct _Concept;
|
|
|
|
// NB: _Tvaluetype and _Ttesttype must be literal types.
|
|
// Additional constraint on _Tvaluetype needed. Either assume
|
|
// user-defined default ctor as per
|
|
// constexpr_default_constructible and provide no initializer,
|
|
// provide an initializer, or assume empty-list init-able. Choose
|
|
// the latter.
|
|
template<typename _Ttesttype, typename _Tvaluetype>
|
|
struct _Concept<_Ttesttype, _Tvaluetype, true>
|
|
{
|
|
void __constraint()
|
|
{
|
|
constexpr _Tvaluetype __v { };
|
|
constexpr _Ttesttype __obj(__v);
|
|
}
|
|
};
|
|
|
|
template<typename _Ttesttype, typename _Tvaluetype>
|
|
struct _Concept<_Ttesttype, _Tvaluetype, false>
|
|
{
|
|
void __constraint()
|
|
{
|
|
const _Tvaluetype __v { };
|
|
static _Ttesttype __obj(__v);
|
|
}
|
|
};
|
|
|
|
template<typename _Ttesttype, typename _Tvaluetype>
|
|
void
|
|
operator()()
|
|
{
|
|
_Concept<_Ttesttype, _Tvaluetype> c;
|
|
c.__constraint();
|
|
}
|
|
};
|
|
#endif
|
|
|
|
// Generator to test direct list initialization
|
|
#if __cplusplus >= 201103L
|
|
struct direct_list_initializable
|
|
{
|
|
template<typename _Ttype, typename _Tvalue>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
_Ttype __v1 { }; // default ctor
|
|
_Ttype __v2 { __a }; // single-argument ctor
|
|
}
|
|
|
|
_Tvalue __a;
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
#endif
|
|
|
|
// Generator to test copy list initialization, aggregate initialization
|
|
struct copy_list_initializable
|
|
{
|
|
template<typename _Ttype, typename _Tvalue>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{ _Ttype __v __attribute__((unused)) = {__a}; }
|
|
|
|
_Tvalue __a;
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
// Generator to test integral conversion operator
|
|
struct integral_convertable
|
|
{
|
|
template<typename _Ttype, typename _Tvalue>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
_Tvalue __v0(0);
|
|
_Tvalue __v1(1);
|
|
_Ttype __a(__v1);
|
|
__v0 = __a;
|
|
|
|
bool test __attribute__((unused)) = true;
|
|
VERIFY( __v1 == __v0 );
|
|
}
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
// Generator to test integral assignment operator
|
|
struct integral_assignable
|
|
{
|
|
template<typename _Ttype, typename _Tvalue>
|
|
void
|
|
operator()()
|
|
{
|
|
struct _Concept
|
|
{
|
|
void __constraint()
|
|
{
|
|
_Tvalue __v0(0);
|
|
_Tvalue __v1(1);
|
|
_Ttype __a(__v0);
|
|
__a = __v1;
|
|
_Tvalue __vr = __a;
|
|
|
|
bool test __attribute__((unused)) = true;
|
|
VERIFY( __v1 == __vr );
|
|
}
|
|
};
|
|
|
|
void (_Concept::*__x)() __attribute__((unused))
|
|
= &_Concept::__constraint;
|
|
}
|
|
};
|
|
|
|
#if __cplusplus >= 201103L
|
|
// Generator to test lowering requirements for compare-and-exchange.
|
|
template<std::memory_order _Torder>
|
|
struct compare_exchange_order_lowering
|
|
{
|
|
template<typename _Tp>
|
|
void
|
|
operator()()
|
|
{
|
|
std::atomic<_Tp> __x;
|
|
_Tp __expected = 0;
|
|
__x.compare_exchange_strong(__expected, 1, _Torder);
|
|
__x.compare_exchange_weak(__expected, 1, _Torder);
|
|
}
|
|
};
|
|
#endif
|
|
} // namespace __gnu_test
|
|
#endif
|