#ifndef TEST_SUPPORT_ARCHETYPES_HPP
|
#define TEST_SUPPORT_ARCHETYPES_HPP
|
|
#include <type_traits>
|
#include <cassert>
|
|
#include "test_macros.h"
|
#include "test_workarounds.h"
|
|
#if TEST_STD_VER >= 11
|
|
namespace ArchetypeBases {
|
|
template <bool, class T>
|
struct DepType : T {};
|
|
struct NullBase {
|
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
|
protected:
|
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
|
NullBase() = default;
|
NullBase(NullBase const&) = default;
|
NullBase& operator=(NullBase const&) = default;
|
NullBase(NullBase &&) = default;
|
NullBase& operator=(NullBase &&) = default;
|
};
|
|
template <class Derived, bool Explicit = false>
|
struct TestBase {
|
static int alive;
|
static int constructed;
|
static int value_constructed;
|
static int default_constructed;
|
static int copy_constructed;
|
static int move_constructed;
|
static int assigned;
|
static int value_assigned;
|
static int copy_assigned;
|
static int move_assigned;
|
static int destroyed;
|
|
static void reset() {
|
assert(alive == 0);
|
alive = 0;
|
reset_constructors();
|
}
|
|
static void reset_constructors() {
|
constructed = value_constructed = default_constructed =
|
copy_constructed = move_constructed = 0;
|
assigned = value_assigned = copy_assigned = move_assigned = destroyed = 0;
|
}
|
|
TestBase() noexcept : value(0) {
|
++alive; ++constructed; ++default_constructed;
|
}
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit TestBase(int x) noexcept : value(x) {
|
++alive; ++constructed; ++value_constructed;
|
}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
TestBase(int x) noexcept : value(x) {
|
++alive; ++constructed; ++value_constructed;
|
}
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit TestBase(int, int y) noexcept : value(y) {
|
++alive; ++constructed; ++value_constructed;
|
}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
TestBase(int, int y) noexcept : value(y) {
|
++alive; ++constructed; ++value_constructed;
|
}
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
|
: value(static_cast<int>(il.size())) {
|
++alive; ++constructed; ++value_constructed;
|
}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(static_cast<int>(il.size())) {
|
++alive; ++constructed; ++value_constructed;
|
}
|
TestBase& operator=(int xvalue) noexcept {
|
value = xvalue;
|
++assigned; ++value_assigned;
|
return *this;
|
}
|
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
|
protected:
|
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
|
~TestBase() {
|
assert(value != -999); assert(alive > 0);
|
--alive; ++destroyed; value = -999;
|
}
|
explicit TestBase(TestBase const& o) noexcept : value(o.value) {
|
assert(o.value != -1); assert(o.value != -999);
|
++alive; ++constructed; ++copy_constructed;
|
}
|
explicit TestBase(TestBase && o) noexcept : value(o.value) {
|
assert(o.value != -1); assert(o.value != -999);
|
++alive; ++constructed; ++move_constructed;
|
o.value = -1;
|
}
|
TestBase& operator=(TestBase const& o) noexcept {
|
assert(o.value != -1); assert(o.value != -999);
|
++assigned; ++copy_assigned;
|
value = o.value;
|
return *this;
|
}
|
TestBase& operator=(TestBase&& o) noexcept {
|
assert(o.value != -1); assert(o.value != -999);
|
++assigned; ++move_assigned;
|
value = o.value;
|
o.value = -1;
|
return *this;
|
}
|
public:
|
int value;
|
};
|
|
template <class D, bool E> int TestBase<D, E>::alive = 0;
|
template <class D, bool E> int TestBase<D, E>::constructed = 0;
|
template <class D, bool E> int TestBase<D, E>::value_constructed = 0;
|
template <class D, bool E> int TestBase<D, E>::default_constructed = 0;
|
template <class D, bool E> int TestBase<D, E>::copy_constructed = 0;
|
template <class D, bool E> int TestBase<D, E>::move_constructed = 0;
|
template <class D, bool E> int TestBase<D, E>::assigned = 0;
|
template <class D, bool E> int TestBase<D, E>::value_assigned = 0;
|
template <class D, bool E> int TestBase<D, E>::copy_assigned = 0;
|
template <class D, bool E> int TestBase<D, E>::move_assigned = 0;
|
template <class D, bool E> int TestBase<D, E>::destroyed = 0;
|
|
template <bool Explicit = false>
|
struct ValueBase {
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit constexpr ValueBase(int x) : value(x) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
constexpr ValueBase(int x) : value(x) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit constexpr ValueBase(int, int y) : value(y) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
constexpr ValueBase(int, int y) : value(y) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
|
TEST_CONSTEXPR_CXX14 ValueBase& operator=(int xvalue) noexcept {
|
value = xvalue;
|
return *this;
|
}
|
//~ValueBase() { assert(value != -999); value = -999; }
|
int value;
|
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
|
protected:
|
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
|
constexpr static int check_value(int const& val) {
|
#if TEST_STD_VER < 14
|
return val == -1 || val == 999 ? (TEST_THROW(42), 0) : val;
|
#else
|
assert(val != -1); assert(val != 999);
|
return val;
|
#endif
|
}
|
constexpr static int check_value(int& val, int val_cp = 0) {
|
#if TEST_STD_VER < 14
|
return val_cp = val, val = -1, (val_cp == -1 || val_cp == 999 ? (TEST_THROW(42), 0) : val_cp);
|
#else
|
assert(val != -1); assert(val != 999);
|
val_cp = val;
|
val = -1;
|
return val_cp;
|
#endif
|
}
|
constexpr ValueBase() noexcept : value(0) {}
|
constexpr ValueBase(ValueBase const& o) noexcept : value(check_value(o.value)) {
|
}
|
constexpr ValueBase(ValueBase && o) noexcept : value(check_value(o.value)) {
|
}
|
TEST_CONSTEXPR_CXX14 ValueBase& operator=(ValueBase const& o) noexcept {
|
assert(o.value != -1); assert(o.value != -999);
|
value = o.value;
|
return *this;
|
}
|
TEST_CONSTEXPR_CXX14 ValueBase& operator=(ValueBase&& o) noexcept {
|
assert(o.value != -1); assert(o.value != -999);
|
value = o.value;
|
o.value = -1;
|
return *this;
|
}
|
};
|
|
|
template <bool Explicit = false>
|
struct TrivialValueBase {
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit constexpr TrivialValueBase(int x) : value(x) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
constexpr TrivialValueBase(int x) : value(x) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit constexpr TrivialValueBase(int, int y) : value(y) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
constexpr TrivialValueBase(int, int y) : value(y) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
|
explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
|
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
|
constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
|
int value;
|
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
|
protected:
|
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
|
constexpr TrivialValueBase() noexcept : value(0) {}
|
};
|
|
}
|
|
//============================================================================//
|
// Trivial Implicit Test Types
|
namespace ImplicitTypes {
|
#include "archetypes.ipp"
|
}
|
|
//============================================================================//
|
// Trivial Explicit Test Types
|
namespace ExplicitTypes {
|
#define DEFINE_EXPLICIT explicit
|
#include "archetypes.ipp"
|
}
|
|
//============================================================================//
|
//
|
namespace NonConstexprTypes {
|
#define DEFINE_CONSTEXPR
|
#include "archetypes.ipp"
|
}
|
|
//============================================================================//
|
// Non-literal implicit test types
|
namespace NonLiteralTypes {
|
#define DEFINE_ASSIGN_CONSTEXPR
|
#define DEFINE_DTOR(Name) ~Name() {}
|
#include "archetypes.ipp"
|
}
|
|
//============================================================================//
|
// Non-throwing implicit test types
|
namespace NonThrowingTypes {
|
#define DEFINE_NOEXCEPT noexcept
|
#include "archetypes.ipp"
|
}
|
|
//============================================================================//
|
// Non-Trivially Copyable Implicit Test Types
|
namespace NonTrivialTypes {
|
#define DEFINE_CTOR {}
|
#define DEFINE_ASSIGN { return *this; }
|
#include "archetypes.ipp"
|
}
|
|
//============================================================================//
|
// Implicit counting types
|
namespace TestTypes {
|
#define DEFINE_CONSTEXPR
|
#define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name>
|
#include "archetypes.ipp"
|
|
using TestType = AllCtors;
|
|
// Add equality operators
|
template <class Tp>
|
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
|
return L.value == R.value;
|
}
|
|
template <class Tp>
|
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
|
return L.value != R.value;
|
}
|
|
}
|
|
//============================================================================//
|
// Implicit counting types
|
namespace ExplicitTestTypes {
|
#define DEFINE_CONSTEXPR
|
#define DEFINE_EXPLICIT explicit
|
#define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name, true>
|
#include "archetypes.ipp"
|
|
using TestType = AllCtors;
|
|
// Add equality operators
|
template <class Tp>
|
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
|
return L.value == R.value;
|
}
|
|
template <class Tp>
|
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
|
return L.value != R.value;
|
}
|
|
}
|
|
//============================================================================//
|
// Implicit value types
|
namespace ConstexprTestTypes {
|
#define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<>
|
#include "archetypes.ipp"
|
|
using TestType = AllCtors;
|
|
// Add equality operators
|
template <class Tp>
|
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
|
return L.value == R.value;
|
}
|
|
template <class Tp>
|
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
|
return L.value != R.value;
|
}
|
|
} // end namespace ConstexprTestTypes
|
|
|
//============================================================================//
|
//
|
namespace ExplicitConstexprTestTypes {
|
#define DEFINE_EXPLICIT explicit
|
#define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<true>
|
#include "archetypes.ipp"
|
|
using TestType = AllCtors;
|
|
// Add equality operators
|
template <class Tp>
|
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
|
return L.value == R.value;
|
}
|
|
template <class Tp>
|
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
|
return L.value != R.value;
|
}
|
|
} // end namespace ExplicitConstexprTestTypes
|
|
|
//============================================================================//
|
//
|
namespace TrivialTestTypes {
|
#define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<false>
|
#include "archetypes.ipp"
|
|
using TestType = AllCtors;
|
|
// Add equality operators
|
template <class Tp>
|
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
|
return L.value == R.value;
|
}
|
|
template <class Tp>
|
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
|
return L.value != R.value;
|
}
|
|
} // end namespace TrivialTestTypes
|
|
//============================================================================//
|
//
|
namespace ExplicitTrivialTestTypes {
|
#define DEFINE_EXPLICIT explicit
|
#define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<true>
|
#include "archetypes.ipp"
|
|
using TestType = AllCtors;
|
|
// Add equality operators
|
template <class Tp>
|
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
|
return L.value == R.value;
|
}
|
|
template <class Tp>
|
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
|
return L.value != R.value;
|
}
|
|
} // end namespace ExplicitTrivialTestTypes
|
|
#endif // TEST_STD_VER >= 11
|
|
#endif // TEST_SUPPORT_ARCHETYPES_HPP
|
