Tester< Const, ref > Struct Template Reference

Parameterize for the type of visitor return. More...

Classes
struct	CopyOnly
struct	X
struct	Y
	Structure can specialize with only a non-const member function. More...
struct	Z
	Structure always with a const member function. More...

Public Types
template<typename T >
using	MaybeConst = std::conditional_t< Const, const T, T >
using	ResultType = std::conditional_t< ref==noref, MaybeConst< ValueType >, std::conditional_t< ref==rvalue, std::add_rvalue_reference_t< MaybeConst< ValueType > >, std::add_lvalue_reference_t< MaybeConst< ValueType > > > >
using	VariantType = std::conditional_t< ref==lvalue, std::variant< MaybeConst< X >, MaybeConst< Y >, MaybeConst< Z >, MaybeConst< float >, MaybeConst< double >, MaybeConst< long double > >, std::variant< MaybeConst< Y >, MaybeConst< Z >, MaybeConst< float >, MaybeConst< double >, MaybeConst< long double > > >

Public Member Functions
void	DoTests ()

Static Public Member Functions
template<int Value>
static ResultType	value ()
static ResultType	nakedFunction (float)
static auto	moveOnly ()
template<typename Visitor , typename Arg >
static void	testCase (const Visitor &visitor, int result, Arg &arg)

Detailed Description

template<bool Const, Ref ref = lvalue>
struct Tester< Const, ref >

Parameterize for the type of visitor return.

Definition at line 29 of file VariantTest.cpp.

Member Typedef Documentation

MaybeConst

template<bool Const, Ref ref = lvalue>

template<typename T >

using Tester< Const, ref >::MaybeConst = std::conditional_t<Const, const T, T>

Definition at line 32 of file VariantTest.cpp.

ResultType

template<bool Const, Ref ref = lvalue>

using Tester< Const, ref >::ResultType = std::conditional_t<ref == noref, MaybeConst<ValueType>, std::conditional_t<ref == rvalue, std::add_rvalue_reference_t<MaybeConst<ValueType> >, std::add_lvalue_reference_t<MaybeConst<ValueType> > > >

Definition at line 34 of file VariantTest.cpp.

VariantType

template<bool Const, Ref ref = lvalue>

using Tester< Const, ref >::VariantType = std::conditional_t<ref == lvalue, std::variant< MaybeConst<X>, MaybeConst<Y>, MaybeConst<Z>, MaybeConst<float>, MaybeConst<double>, MaybeConst<long double> >, std::variant< MaybeConst<Y>, MaybeConst<Z>, MaybeConst<float>, MaybeConst<double>, MaybeConst<long double> > >

Definition at line 88 of file VariantTest.cpp.

Member Function Documentation

DoTests()

template<bool Const, Ref ref = lvalue>

void Tester< Const, ref >::DoTests ( )

inline

Definition at line 133 of file VariantTest.cpp.

{
   // Callable::OverloadSet can capture many kinds of things.  Test each.
   // This also tests compilation of the variadic constructor of OverloadSet
   // which can take a mix of l- and rvalues.
   CopyOnly copyOnly;
   const auto visitor = Callable::OverloadSet(
      &X::member,
      &Y::template memberfunction<Const>,
      &Z::constmemberfunction,
      nakedFunction,
      moveOnly(),
      copyOnly
   );
 
   X x;
   Y y;
   Z z;
   float f{};
   double d{};
   long double ld{};
 
   // Pointer to data member, captured as INVOKE-able, can only return lvalue
   // references, so it is excluded from other test cases
   if constexpr (ref == lvalue)
      testCase(visitor, 0, x);
 
   testCase(visitor, 1, y);
   testCase(visitor, 2, z);
   testCase(visitor, 3, f);
   testCase(visitor, 4, d);
   testCase(visitor, 5, ld);
 
   // An invocable can distinguish its own value category and constness
   REQUIRE(6 == std::move(visitor)(ld));
   using ConstVisitorType = decltype(visitor);
   using VisitorType = std::remove_const_t<ConstVisitorType>;
   auto &mutVisitor = const_cast<VisitorType&>(visitor);
   REQUIRE(7 == mutVisitor(ld));
   REQUIRE(8 == std::move(mutVisitor)(ld));
}

References Tester< Const, ref >::Z::constmemberfunction(), lvalue, Tester< Const, ref >::X::member, Tester< Const, ref >::moveOnly(), Tester< Const, ref >::nakedFunction(), Callable::OverloadSet(), and Tester< Const, ref >::testCase().

Referenced by TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

moveOnly()

template<bool Const, Ref ref = lvalue>

static auto Tester< Const, ref >::moveOnly ( )

inlinestatic

Definition at line 66 of file VariantTest.cpp.

                       {
   // Note: remove trailing return type and compilation of Visit correctly
   // breaks because a value, not reference results for one alternative
   return [u = std::make_unique<X>()](double) -> ResultType
                                                { return value<4>(); };
}

Referenced by Tester< Const, ref >::DoTests().

Here is the caller graph for this function:

nakedFunction()

template<bool Const, Ref ref = lvalue>

static ResultType Tester< Const, ref >::nakedFunction ( float  )

inlinestatic

Definition at line 65 of file VariantTest.cpp.

{ return value<3>(); }

Referenced by Tester< Const, ref >::DoTests().

Here is the caller graph for this function:

testCase()

template<bool Const, Ref ref = lvalue>

template<typename Visitor , typename Arg >

static void Tester< Const, ref >::testCase ( const Visitor &  visitor, int  result, Arg &  arg  )

inlinestatic

Definition at line 108 of file VariantTest.cpp.

{
   if constexpr(Const)
   {
      const std::remove_reference_t<decltype(arg)> carg{ arg };
      const VariantType cv{ carg };
      REQUIRE(result == visitor(carg));
      REQUIRE(result == Visit(visitor, cv));
      if constexpr (ref != lvalue) {
         REQUIRE(result == visitor(std::move(carg)));
         REQUIRE(result == Visit(visitor, move(cv)));
      }
   }
 
   {
      VariantType v{ arg };
      REQUIRE(result == visitor(arg));
      REQUIRE(result == Visit(visitor, v));
      if constexpr (ref != lvalue) {
         REQUIRE(result == visitor(std::move(arg)));
         REQUIRE(result == Visit(visitor, move(v)));
      }
   }
};

References lvalue, and MenuRegistry::Visit().

Referenced by Tester< Const, ref >::DoTests().

Here is the call graph for this function:

Here is the caller graph for this function:

value()

template<bool Const, Ref ref = lvalue>

template<int Value>

static ResultType Tester< Const, ref >::value ( )

inlinestatic

Definition at line 43 of file VariantTest.cpp.

                          {
   static MaybeConst<ValueType> x{ Value };
   if constexpr (ref == rvalue)
      return std::move(x);
   else
      return x;
}

References rvalue.

---

The documentation for this struct was generated from the following file:

• VariantTest.cpp