TypeListTest.cpp File Reference

#include <folly/detail/TypeList.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	Cons< Car, Cdr >

Typedefs
template<class T >
using	AddPointer = T *
using	Nil = Empty

Functions
	TEST (TypeList, Basic)
	TEST (TypeList, Defer)
	TEST (TypeList, Transform)
	TEST (TypeList, Fold)
	TEST (TypeList, Unique)
	TEST (TypeList, PushFront)
	TEST (TypeList, PushBack)
	TEST (TypeList, Join)

Typedef Documentation

template<class T >

using AddPointer = T*

Definition at line 40 of file TypeListTest.cpp.

using Nil = Empty

Definition at line 59 of file TypeListTest.cpp.

Function Documentation

TEST	(	TypeList	,
		Basic
	)

Definition at line 33 of file TypeListTest.cpp.

                      {
  static_assert(TypeList<>::size() == 0, "");
  static_assert(TypeList<int>::size() == 1, "");
  static_assert(TypeList<int, short, float>::size() == 3, "");
}

TEST	(	TypeList	,
		Defer
	)

Definition at line 42 of file TypeListTest.cpp.

References folly::value().

                      {
  static_assert(
      std::is_same<MetaApply<MetaDefer<AddPointer, int>>, int*>::value, "");
  static_assert(!IsApplicable<MetaDefer<AddPointer, int, short>>::value, "");
  static_assert(!IsApplicable<MetaDefer<AddPointer, int&>>::value, "");
}

TEST	(	TypeList	,
		Transform
	)

Definition at line 49 of file TypeListTest.cpp.

References folly::value().

                          {
  using Fn = MetaQuote<AddPointer>;
  using T1 = TypeTransform<TypeList<>, Fn>;
  static_assert(std::is_same<T1, TypeList<>>::value, "");
  using T2 = TypeTransform<TypeList<int>, Fn>;
  static_assert(std::is_same<T2, TypeList<int*>>::value, "");
  using T3 = TypeTransform<TypeList<int, short, void>, Fn>;
  static_assert(std::is_same<T3, TypeList<int*, short*, void*>>::value, "");
}

TEST	(	TypeList	,
		Fold
	)

Definition at line 63 of file TypeListTest.cpp.

References folly::E1, folly::E2, and value.

                     {
  using Fn = MetaQuote<Cons>;
  using T1 = TypeFold<TypeList<int, short, void>, Nil, Fn>;
  using E1 = Cons<int, Cons<short, Cons<void, Nil>>>;
  static_assert(std::is_same<T1, E1>::value, "");

  using T2 = TypeFold<TypeList<int, short, void, int*, short*, void*>, Nil, Fn>;
  using E2 = Cons<
      int,
      Cons<short, Cons<void, Cons<int*, Cons<short*, Cons<void*, Nil>>>>>>;
  static_assert(std::is_same<T2, E2>::value, "");

  using T3 = TypeReverseFold<TypeList<int, short, void>, Nil, MetaFlip<Fn>>;
  using E3 = Cons<void, Cons<short, Cons<int, Nil>>>;
  static_assert(std::is_same<T3, E3>::value, "");

  using T4 = TypeReverseFold<
      TypeList<int, short, void, int*, short*, void*>,
      Nil,
      MetaFlip<Fn>>;
  using E4 = Cons<
      void*,
      Cons<short*, Cons<int*, Cons<void, Cons<short, Cons<int, Nil>>>>>>;
  static_assert(std::is_same<T4, E4>::value, "");
}

TEST	(	TypeList	,
		Unique
	)

Definition at line 89 of file TypeListTest.cpp.

References folly::value().

                       {
  using T1 = TypeUnique<TypeList<int, int, int, short, int, short>>;
  static_assert(std::is_same<T1, TypeList<int, short>>::value, "");

  using T2 = TypeReverseUnique<TypeList<int, int, int, short, int, short>>;
  static_assert(std::is_same<T2, TypeList<short, int>>::value, "");
}

TEST	(	TypeList	,
		PushFront
	)

Definition at line 97 of file TypeListTest.cpp.

References folly::value().

                          {
  using T1 = TypePushFront<TypeList<>, int, short>;
  static_assert(std::is_same<T1, TypeList<int, short>>::value, "");

  using T2 = TypePushFront<T1, float, double, struct XXX>;
  static_assert(
      std::is_same<T2, TypeList<float, double, struct XXX, int, short>>::value,
      "");
}

TEST	(	TypeList	,
		PushBack
	)

Definition at line 107 of file TypeListTest.cpp.

References folly::value().

                         {
  using T1 = TypePushBack<TypeList<>, int, short>;
  static_assert(std::is_same<T1, TypeList<int, short>>::value, "");

  using T2 = TypePushBack<T1, float, double, struct XXX>;
  static_assert(
      std::is_same<T2, TypeList<int, short, float, double, struct XXX>>::value,
      "");
}

TEST	(	TypeList	,
		Join
	)

Definition at line 117 of file TypeListTest.cpp.

References folly::value().

                     {
  using T1 = TypeJoin<
      TypeList<TypeList<int>, TypeList<short, float>, TypeList<void*>>>;
  static_assert(
      std::is_same<T1, TypeList<int, short, float, void*>>::value, "");
}