ReplaceableTest.cpp File Reference

#include <folly/Replaceable.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	ReplaceableStaticAttributeTest< T >
struct	ReplaceableStaticAttributePairTest< T >

Typedefs
using	StaticAttributeTypes = ::testing::Types< char, short, int, long, float, double, char[11], Basic, BigAlign, HasConst, HasRef, OddA, OddB, Indestructible >
using	StaticAttributePairTypes = ::testing::Types< std::pair< int, long >, std::pair< OddA, OddB >, std::pair< OddB, OddA >>

Functions
	TYPED_TEST_CASE (ReplaceableStaticAttributeTest, StaticAttributeTypes)
	TYPED_TEST_CASE (ReplaceableStaticAttributePairTest, StaticAttributePairTypes)
	TYPED_TEST (ReplaceableStaticAttributeTest, size)
	TYPED_TEST (ReplaceableStaticAttributeTest, align)
	TYPED_TEST (ReplaceableStaticAttributeTest, destructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, trivially_destructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, default_constructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, move_constructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, copy_constructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, move_assignable)
	TYPED_TEST (ReplaceableStaticAttributeTest, copy_assignable)
	TYPED_TEST (ReplaceableStaticAttributeTest, nothrow_destructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, nothrow_default_constructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, nothrow_move_constructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, nothrow_copy_constructible)
	TYPED_TEST (ReplaceableStaticAttributeTest, nothrow_move_assignable)
	TYPED_TEST (ReplaceableStaticAttributeTest, nothrow_copy_assignable)
	TYPED_TEST (ReplaceableStaticAttributeTest, replaceable)
	TYPED_TEST (ReplaceableStaticAttributePairTest, copy_construct)
	TYPED_TEST (ReplaceableStaticAttributePairTest, move_construct)
	TYPED_TEST (ReplaceableStaticAttributePairTest, copy_assign)
	TYPED_TEST (ReplaceableStaticAttributePairTest, move_assign)
	TYPED_TEST (ReplaceableStaticAttributePairTest, nothrow_copy_construct)
	TYPED_TEST (ReplaceableStaticAttributePairTest, nothrow_move_construct)
	TYPED_TEST (ReplaceableStaticAttributePairTest, nothrow_copy_assign)
	TYPED_TEST (ReplaceableStaticAttributePairTest, nothrow_move_assign)
	TEST (ReplaceableTest, Basics)
	TEST (ReplaceableTest, Constructors)
	TEST (ReplaceableTest, DestructsWhenExpected)
	TEST (ReplaceableTest, Conversions)

Typedef Documentation

using StaticAttributePairTypes = ::testing:: Types<std::pair<int, long>, std::pair<OddA, OddB>, std::pair<OddB, OddA>>

Definition at line 97 of file ReplaceableTest.cpp.

using StaticAttributeTypes = ::testing::Types< char, short, int, long, float, double, char[11], Basic, BigAlign, HasConst, HasRef, OddA, OddB, Indestructible>

Definition at line 91 of file ReplaceableTest.cpp.

Function Documentation

TEST	(	ReplaceableTest	,
		Basics
	)

Definition at line 243 of file ReplaceableTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and folly::gen::move.

                              {
  auto rHasConstA = make_replaceable<HasConst>();
  auto rHasConstB = make_replaceable<HasConst>(false);
  EXPECT_TRUE(rHasConstA->b1);
  EXPECT_FALSE(rHasConstB->b1);
  rHasConstA = rHasConstB;
  EXPECT_FALSE(rHasConstA->b1);
  EXPECT_FALSE(rHasConstB->b1);
  rHasConstB.emplace(true);
  EXPECT_FALSE(rHasConstA->b1);
  EXPECT_TRUE(rHasConstB->b1);
  rHasConstA = std::move(rHasConstB);
  EXPECT_TRUE(rHasConstA->b1);
  EXPECT_TRUE(rHasConstB->b1);
}

TEST	(	ReplaceableTest	,
		Constructors
	)

Definition at line 259 of file ReplaceableTest.cpp.

References b, and folly::gen::move.

                                    {
  Basic b{};
  // From existing `T`
  auto rBasicCopy1 = Replaceable<Basic>(b);
  auto rBasicMove1 = Replaceable<Basic>(std::move(b));
  // From existing `Replaceable<T>`
  auto rBasicCopy2 = Replaceable<Basic>(rBasicCopy1);
  auto rBasicMove2 = Replaceable<Basic>(std::move(rBasicMove1));
  (void)rBasicCopy2;
  (void)rBasicMove2;
}

TEST	(	ReplaceableTest	,
		DestructsWhenExpected
	)

Definition at line 271 of file ReplaceableTest.cpp.

References EXPECT_EQ, i, and folly::gen::move.

                                             {
  int i{0};
  {
    Replaceable<HasRef> rHasRefA{i};
    Replaceable<HasRef> rHasRefB{i};
    EXPECT_EQ(0, i);
    rHasRefA = rHasRefB;
    EXPECT_EQ(1, i);
    rHasRefB.emplace(i);
    EXPECT_EQ(2, i);
    rHasRefA = std::move(rHasRefB);
    EXPECT_EQ(3, i);
  }
  EXPECT_EQ(5, i);
}

TEST	(	ReplaceableTest	,
		Conversions
	)

Definition at line 287 of file ReplaceableTest.cpp.

References folly::in_place(), and folly::gen::move.

                                   {
  Replaceable<OddB> rOddB{in_place, {1, 2, 3}, 4};
  Replaceable<OddA> rOddA{std::move(rOddB)};
  Replaceable<OddB> rOddB2{rOddA};
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		size
	)

Definition at line 100 of file ReplaceableTest.cpp.

References EXPECT_EQ.

                                                 {
  EXPECT_EQ(sizeof(TypeParam), sizeof(Replaceable<TypeParam>));
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		align
	)

Definition at line 103 of file ReplaceableTest.cpp.

References EXPECT_EQ.

                                                  {
  EXPECT_EQ(alignof(TypeParam), alignof(Replaceable<TypeParam>));
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		destructible
	)

Definition at line 106 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                         {
  EXPECT_EQ(
      std::is_destructible<TypeParam>::value,
      std::is_destructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		trivially_destructible
	)

Definition at line 111 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                                   {
  EXPECT_EQ(
      std::is_trivially_destructible<TypeParam>::value,
      std::is_trivially_destructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		default_constructible
	)

Definition at line 116 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                                  {
  EXPECT_EQ(
      std::is_default_constructible<TypeParam>::value,
      std::is_default_constructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		move_constructible
	)

Definition at line 121 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                               {
  EXPECT_EQ(
      std::is_move_constructible<TypeParam>::value,
      std::is_move_constructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		copy_constructible
	)

Definition at line 126 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                               {
  EXPECT_EQ(
      std::is_copy_constructible<TypeParam>::value,
      std::is_copy_constructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		move_assignable
	)

Definition at line 131 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                            {
  EXPECT_EQ(
      std::is_move_constructible<TypeParam>::value,
      std::is_move_assignable<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		copy_assignable
	)

Definition at line 136 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                            {
  EXPECT_EQ(
      std::is_copy_constructible<TypeParam>::value,
      std::is_copy_assignable<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		nothrow_destructible
	)

Definition at line 141 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                                 {
  EXPECT_EQ(
      std::is_nothrow_destructible<TypeParam>::value,
      std::is_nothrow_destructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		nothrow_default_constructible
	)

Definition at line 146 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                                          {
  EXPECT_EQ(
      std::is_nothrow_default_constructible<TypeParam>::value,
      std::is_nothrow_default_constructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		nothrow_move_constructible
	)

Definition at line 151 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                                       {
  EXPECT_EQ(
      std::is_nothrow_move_constructible<TypeParam>::value,
      std::is_nothrow_move_constructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		nothrow_copy_constructible
	)

Definition at line 156 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                                       {
  EXPECT_EQ(
      std::is_nothrow_copy_constructible<TypeParam>::value,
      std::is_nothrow_copy_constructible<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		nothrow_move_assignable
	)

Definition at line 161 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                                    {
  EXPECT_EQ(
      std::is_nothrow_destructible<TypeParam>::value &&
          std::is_nothrow_copy_constructible<TypeParam>::value,
      std::is_nothrow_move_assignable<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		nothrow_copy_assignable
	)

Definition at line 167 of file ReplaceableTest.cpp.

References EXPECT_EQ, and value.

                                                                    {
  EXPECT_EQ(
      std::is_nothrow_destructible<TypeParam>::value &&
          std::is_nothrow_copy_constructible<TypeParam>::value,
      std::is_nothrow_copy_assignable<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributeTest	,
		replaceable
	)

Definition at line 173 of file ReplaceableTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                                        {
  EXPECT_FALSE(is_replaceable<TypeParam>::value);
  EXPECT_TRUE(is_replaceable<Replaceable<TypeParam>>::value);
}

TYPED_TEST	(	ReplaceableStaticAttributePairTest	,
		copy_construct
	)

Definition at line 178 of file ReplaceableTest.cpp.

References EXPECT_EQ, T, and value.

                                                               {
  using T = typename TypeParam::first_type;
  using U = typename TypeParam::second_type;
  EXPECT_EQ(
      (std::is_constructible<T, U const&>::value),
      (std::is_constructible<Replaceable<T>, Replaceable<U> const&>::value));
}

TYPED_TEST	(	ReplaceableStaticAttributePairTest	,
		move_construct
	)

Definition at line 185 of file ReplaceableTest.cpp.

References EXPECT_EQ, T, and value.

                                                               {
  using T = typename TypeParam::first_type;
  using U = typename TypeParam::second_type;
  EXPECT_EQ(
      (std::is_constructible<T, U&&>::value),
      (std::is_constructible<Replaceable<T>, Replaceable<U>&&>::value));
}

TYPED_TEST	(	ReplaceableStaticAttributePairTest	,
		copy_assign
	)

Definition at line 192 of file ReplaceableTest.cpp.

References EXPECT_EQ, T, and value.

                                                            {
  using T = typename TypeParam::first_type;
  using U = typename TypeParam::second_type;
  EXPECT_EQ(
      (std::is_convertible<U, T>::value && std::is_destructible<T>::value &&
       std::is_copy_constructible<T>::value),
      (std::is_assignable<Replaceable<T>, Replaceable<U> const&>::value));
}

TYPED_TEST	(	ReplaceableStaticAttributePairTest	,
		move_assign
	)

Definition at line 200 of file ReplaceableTest.cpp.

References EXPECT_EQ, T, and value.

                                                            {
  using T = typename TypeParam::first_type;
  using U = typename TypeParam::second_type;
  EXPECT_EQ(
      (std::is_convertible<U, T>::value && std::is_destructible<T>::value &&
       std::is_move_constructible<T>::value),
      (std::is_assignable<Replaceable<T>, Replaceable<U>&&>::value));
}

TYPED_TEST	(	ReplaceableStaticAttributePairTest	,
		nothrow_copy_construct
	)

Definition at line 208 of file ReplaceableTest.cpp.

References EXPECT_EQ, T, and value.

                                                                       {
  using T = typename TypeParam::first_type;
  using U = typename TypeParam::second_type;
  EXPECT_EQ(
      (std::is_nothrow_constructible<T, U const&>::value &&
       std::is_nothrow_destructible<T>::value),
      (std::is_nothrow_constructible<Replaceable<T>, Replaceable<U> const&>::
           value));
}

TYPED_TEST	(	ReplaceableStaticAttributePairTest	,
		nothrow_move_construct
	)

Definition at line 217 of file ReplaceableTest.cpp.

References EXPECT_EQ, T, and value.

                                                                       {
  using T = typename TypeParam::first_type;
  using U = typename TypeParam::second_type;
  EXPECT_EQ(
      (std::is_nothrow_constructible<T, U&&>::value &&
       std::is_nothrow_destructible<T>::value),
      (std::is_nothrow_constructible<Replaceable<T>, Replaceable<U>&&>::value));
}

TYPED_TEST	(	ReplaceableStaticAttributePairTest	,
		nothrow_copy_assign
	)

Definition at line 225 of file ReplaceableTest.cpp.

References EXPECT_EQ, T, and value.

                                                                    {
  using T = typename TypeParam::first_type;
  using U = typename TypeParam::second_type;
  EXPECT_EQ(
      (std::is_nothrow_constructible<T, U const&>::value &&
       std::is_nothrow_destructible<T>::value),
      (std::is_nothrow_assignable<Replaceable<T>, Replaceable<U> const&>::
           value));
}

TYPED_TEST	(	ReplaceableStaticAttributePairTest	,
		nothrow_move_assign
	)

Definition at line 234 of file ReplaceableTest.cpp.

References EXPECT_EQ, T, and value.

                                                                    {
  using T = typename TypeParam::first_type;
  using U = typename TypeParam::second_type;
  EXPECT_EQ(
      (std::is_nothrow_constructible<T, U&&>::value &&
       std::is_nothrow_destructible<T>::value),
      (std::is_nothrow_assignable<Replaceable<T>, Replaceable<U>&&>::value));
}

TYPED_TEST_CASE	(	ReplaceableStaticAttributeTest	,
		StaticAttributeTypes
	)

TYPED_TEST_CASE	(	ReplaceableStaticAttributePairTest	,
		StaticAttributePairTypes
	)