PropagateConstTest.cpp File Reference

#include <folly/lang/PropagateConst.h>
#include <memory>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
class	PropagateConstTest

Typedefs
template<typename T >
using	pc = propagate_const< T >

Functions
template<typename T >
static bool	is_const (T &&)
	TEST_F (PropagateConstTest, construct_assign)
	TEST_F (PropagateConstTest, op_assign_move)
	TEST_F (PropagateConstTest, get)
	TEST_F (PropagateConstTest, op_indirect)
	TEST_F (PropagateConstTest, op_element_type_ptr)
	TEST_F (PropagateConstTest, op_bool)
	TEST_F (PropagateConstTest, get_underlying)
	TEST_F (PropagateConstTest, swap)
	TEST_F (PropagateConstTest, op_equal_to)
	TEST_F (PropagateConstTest, op_not_equal_to)
	TEST_F (PropagateConstTest, op_less)
	TEST_F (PropagateConstTest, op_greater)
	TEST_F (PropagateConstTest, op_less_equal)
	TEST_F (PropagateConstTest, op_greater_equal)
	TEST_F (PropagateConstTest, hash)
	TEST_F (PropagateConstTest, equal_to)
	TEST_F (PropagateConstTest, not_equal_to)
	TEST_F (PropagateConstTest, less)
	TEST_F (PropagateConstTest, greater)
	TEST_F (PropagateConstTest, less_equal)
	TEST_F (PropagateConstTest, greater_equal)

Typedef Documentation

template<typename T >

using pc = propagate_const<T>

Definition at line 38 of file PropagateConstTest.cpp.

Function Documentation

template<typename T >

static bool is_const ( T &&  )

static

Definition at line 33 of file PropagateConstTest.cpp.

References folly::value().

Referenced by TEST_F().

                          {
  return std::is_const<_t<std::remove_reference<T>>>::value;
}

TEST_F	(	PropagateConstTest	,
		construct_assign
	)

Definition at line 40 of file PropagateConstTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and folly::value().

                                             {
  struct Source {
    int& operator*();
    int* get();
  };
  struct Implicit {
    int& operator*();
    int* get();
    /* implicit */ Implicit(Source) {}
  };
  struct Explicit {
    int& operator*();
    int* get();
    explicit Explicit(Source) {}
  };

  EXPECT_TRUE((std::is_constructible<pc<Implicit>, Source>::value));
  EXPECT_TRUE((std::is_constructible<pc<Explicit>, Source>::value));
  EXPECT_TRUE((std::is_convertible<Source, pc<Implicit>>::value));
  EXPECT_FALSE((std::is_convertible<Source, pc<Explicit>>::value));
  EXPECT_TRUE((std::is_assignable<pc<Implicit>, Source>::value));
  EXPECT_FALSE((std::is_assignable<pc<Explicit>, Source>::value));

  EXPECT_TRUE((std::is_constructible<pc<Implicit>, pc<Source>>::value));
  EXPECT_TRUE((std::is_constructible<pc<Explicit>, pc<Source>>::value));
  EXPECT_TRUE((std::is_convertible<pc<Source>, pc<Implicit>>::value));
  EXPECT_FALSE((std::is_convertible<pc<Source>, pc<Explicit>>::value));
  EXPECT_TRUE((std::is_assignable<pc<Implicit>, pc<Source>>::value));
  EXPECT_FALSE((std::is_assignable<pc<Explicit>, pc<Source>>::value));
}

TEST_F	(	PropagateConstTest	,
		op_assign_move
	)

Definition at line 71 of file PropagateConstTest.cpp.

References EXPECT_EQ, and ptr.

                                           {
  auto ptr = pc<std::unique_ptr<int>>{std::make_unique<int>(1)};
  EXPECT_EQ(*ptr, 1);

  ptr = std::make_unique<int>(2);
  EXPECT_EQ(*ptr, 2);
}

TEST_F	(	PropagateConstTest	,
		get
	)

Definition at line 79 of file PropagateConstTest.cpp.

References a, folly::as_const(), folly::data(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, and is_const().

                                {
  int data[1] = {3};
  auto a = data + 0;
  auto pc_a = pc<int*>(a);

  EXPECT_EQ(a, pc_a.get());
  EXPECT_EQ(a, as_const(pc_a).get());
  EXPECT_FALSE(is_const(*pc_a.get()));
  EXPECT_TRUE(is_const(*as_const(pc_a).get()));
}

TEST_F	(	PropagateConstTest	,
		op_indirect
	)

Definition at line 90 of file PropagateConstTest.cpp.

References a, folly::as_const(), folly::data(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, and is_const().

                                        {
  int data[1] = {3};
  auto a = data + 0;
  auto pc_a = pc<int*>(a);

  EXPECT_EQ(a, &*pc_a);
  EXPECT_EQ(a, &*as_const(pc_a));
  EXPECT_FALSE(is_const(*pc_a));
  EXPECT_TRUE(is_const(*as_const(pc_a)));
}

TEST_F	(	PropagateConstTest	,
		op_element_type_ptr
	)

Definition at line 101 of file PropagateConstTest.cpp.

References a, folly::as_const(), folly::data(), and EXPECT_EQ.

                                                {
  int data[1] = {3};
  auto a = data + 0;
  auto pc_a = pc<int*>(a);

  EXPECT_EQ(a, static_cast<int*>(pc_a));
  EXPECT_EQ(a, static_cast<int const*>(as_const(pc_a)));
}

TEST_F	(	PropagateConstTest	,
		op_bool
	)

Definition at line 110 of file PropagateConstTest.cpp.

References a, folly::data(), EXPECT_FALSE, and EXPECT_TRUE.

                                    {
  int data[1] = {3};
  auto a = data + 0;
  auto pc_a = pc<int*>(a);
  auto pc_0 = pc<int*>(nullptr);

  EXPECT_TRUE(pc_a);
  EXPECT_FALSE(pc_0);
}

TEST_F	(	PropagateConstTest	,
		get_underlying
	)

Definition at line 120 of file PropagateConstTest.cpp.

References a, folly::as_const(), folly::data(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::get_underlying(), and is_const().

                                           {
  int data[1] = {3};
  auto a = data + 0;
  auto pc_a = pc<int*>(a);

  EXPECT_EQ(a, get_underlying(pc_a));
  EXPECT_EQ(a, get_underlying(as_const(pc_a)));
  EXPECT_FALSE(is_const(get_underlying(pc_a)));
  EXPECT_TRUE(is_const(get_underlying(as_const(pc_a))));
  EXPECT_TRUE(&get_underlying(pc_a) == &get_underlying(as_const(pc_a)));
}

TEST_F	(	PropagateConstTest	,
		swap
	)

Definition at line 132 of file PropagateConstTest.cpp.

References a, b, folly::data(), EXPECT_EQ, and folly::swap().

                                 {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  swap(pc_a, pc_b);
  EXPECT_EQ(3, *pc_b);
  EXPECT_EQ(4, *pc_a);

  swap(pc_a, pc_b);
  EXPECT_EQ(3, *pc_a);
  EXPECT_EQ(4, *pc_b);
}

TEST_F	(	PropagateConstTest	,
		op_equal_to
	)

Definition at line 148 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, EXPECT_TRUE, and x.

                                        {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = [](auto&& x, auto&& y) { return x == y; };
  EXPECT_TRUE(_(pc_a, pc_a));
  EXPECT_FALSE(_(pc_a, pc_b));
  EXPECT_FALSE(_(pc_a, nullptr));
  EXPECT_TRUE(_(pc_a, a));
  EXPECT_FALSE(_(pc_a, b));
  EXPECT_TRUE(_(a, pc_a));
  EXPECT_FALSE(_(b, pc_a));
}

TEST_F	(	PropagateConstTest	,
		op_not_equal_to
	)

Definition at line 165 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, EXPECT_TRUE, and x.

                                            {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = [](auto&& x, auto&& y) { return x != y; };
  EXPECT_FALSE(_(pc_a, pc_a));
  EXPECT_TRUE(_(pc_a, pc_b));
  EXPECT_TRUE(_(pc_a, nullptr));
  EXPECT_FALSE(_(pc_a, a));
  EXPECT_TRUE(_(pc_a, b));
  EXPECT_FALSE(_(a, pc_a));
  EXPECT_TRUE(_(b, pc_a));
}

TEST_F	(	PropagateConstTest	,
		op_less
	)

Definition at line 182 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, EXPECT_TRUE, and x.

                                    {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = [](auto&& x, auto&& y) { return x < y; };
  EXPECT_FALSE(_(pc_a, pc_a));
  EXPECT_FALSE(_(pc_a, a));
  EXPECT_FALSE(_(a, pc_a));
  EXPECT_TRUE(_(pc_a, pc_b));
  EXPECT_TRUE(_(pc_a, b));
  EXPECT_TRUE(_(a, pc_b));
  EXPECT_FALSE(_(pc_b, pc_a));
  EXPECT_FALSE(_(pc_b, a));
  EXPECT_FALSE(_(b, pc_a));
  EXPECT_FALSE(_(pc_b, pc_b));
  EXPECT_FALSE(_(pc_b, b));
  EXPECT_FALSE(_(b, pc_b));
}

TEST_F	(	PropagateConstTest	,
		op_greater
	)

Definition at line 204 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, EXPECT_TRUE, and x.

                                       {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = [](auto&& x, auto&& y) { return x > y; };
  EXPECT_FALSE(_(pc_a, pc_a));
  EXPECT_FALSE(_(pc_a, a));
  EXPECT_FALSE(_(a, pc_a));
  EXPECT_FALSE(_(pc_a, pc_b));
  EXPECT_FALSE(_(pc_a, b));
  EXPECT_FALSE(_(a, pc_b));
  EXPECT_TRUE(_(pc_b, pc_a));
  EXPECT_TRUE(_(pc_b, a));
  EXPECT_TRUE(_(b, pc_a));
  EXPECT_FALSE(_(pc_b, pc_b));
  EXPECT_FALSE(_(pc_b, b));
  EXPECT_FALSE(_(b, pc_b));
}

TEST_F	(	PropagateConstTest	,
		op_less_equal
	)

Definition at line 226 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, EXPECT_TRUE, and x.

                                          {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = [](auto&& x, auto&& y) { return x <= y; };
  EXPECT_TRUE(_(pc_a, pc_a));
  EXPECT_TRUE(_(pc_a, a));
  EXPECT_TRUE(_(a, pc_a));
  EXPECT_TRUE(_(pc_a, pc_b));
  EXPECT_TRUE(_(pc_a, b));
  EXPECT_TRUE(_(a, pc_b));
  EXPECT_FALSE(_(pc_b, pc_a));
  EXPECT_FALSE(_(pc_b, a));
  EXPECT_FALSE(_(b, pc_a));
  EXPECT_TRUE(_(pc_b, pc_b));
  EXPECT_TRUE(_(pc_b, b));
  EXPECT_TRUE(_(b, pc_b));
}

TEST_F	(	PropagateConstTest	,
		op_greater_equal
	)

Definition at line 248 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, EXPECT_TRUE, and x.

                                             {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = [](auto&& x, auto&& y) { return x >= y; };
  EXPECT_TRUE(_(pc_a, pc_a));
  EXPECT_TRUE(_(pc_a, a));
  EXPECT_TRUE(_(a, pc_a));
  EXPECT_FALSE(_(pc_a, pc_b));
  EXPECT_FALSE(_(pc_a, b));
  EXPECT_FALSE(_(a, pc_b));
  EXPECT_TRUE(_(pc_b, pc_a));
  EXPECT_TRUE(_(pc_b, a));
  EXPECT_TRUE(_(b, pc_a));
  EXPECT_TRUE(_(pc_b, pc_b));
  EXPECT_TRUE(_(pc_b, b));
  EXPECT_TRUE(_(b, pc_b));
}

TEST_F	(	PropagateConstTest	,
		hash
	)

Definition at line 270 of file PropagateConstTest.cpp.

References a, folly::data(), and EXPECT_EQ.

                                 {
  int data[1] = {3};
  auto a = data + 0;
  auto pc_a = pc<int*>(a);

  EXPECT_EQ(std::hash<int*>()(a), std::hash<pc<int*>>()(pc_a));
}

TEST_F	(	PropagateConstTest	,
		equal_to
	)

Definition at line 278 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, and EXPECT_TRUE.

                                     {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = std::equal_to<pc<int*>>{};
  EXPECT_TRUE(_(pc_a, pc_a));
  EXPECT_FALSE(_(pc_a, pc_b));
}

TEST_F	(	PropagateConstTest	,
		not_equal_to
	)

Definition at line 290 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, and EXPECT_TRUE.

                                         {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = std::not_equal_to<pc<int*>>{};
  EXPECT_FALSE(_(pc_a, pc_a));
  EXPECT_TRUE(_(pc_a, pc_b));
}

TEST_F	(	PropagateConstTest	,
		less
	)

Definition at line 302 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, and EXPECT_TRUE.

                                 {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = std::less<pc<int*>>{};
  EXPECT_FALSE(_(pc_a, pc_a));
  EXPECT_TRUE(_(pc_a, pc_b));
  EXPECT_FALSE(_(pc_b, pc_a));
  EXPECT_FALSE(_(pc_b, pc_b));
}

TEST_F	(	PropagateConstTest	,
		greater
	)

Definition at line 316 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, and EXPECT_TRUE.

                                    {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = std::greater<pc<int*>>{};
  EXPECT_FALSE(_(pc_a, pc_a));
  EXPECT_FALSE(_(pc_a, pc_b));
  EXPECT_TRUE(_(pc_b, pc_a));
  EXPECT_FALSE(_(pc_b, pc_b));
}

TEST_F	(	PropagateConstTest	,
		less_equal
	)

Definition at line 330 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, and EXPECT_TRUE.

                                       {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = std::less_equal<pc<int*>>{};
  EXPECT_TRUE(_(pc_a, pc_a));
  EXPECT_TRUE(_(pc_a, pc_b));
  EXPECT_FALSE(_(pc_b, pc_a));
  EXPECT_TRUE(_(pc_b, pc_b));
}

TEST_F	(	PropagateConstTest	,
		greater_equal
	)

Definition at line 344 of file PropagateConstTest.cpp.

References testing::_, a, b, folly::data(), EXPECT_FALSE, and EXPECT_TRUE.

                                          {
  int data[2] = {3, 4};
  auto a = data + 0;
  auto b = data + 1;
  auto pc_a = pc<int*>(a);
  auto pc_b = pc<int*>(b);

  auto _ = std::greater_equal<pc<int*>>{};
  EXPECT_TRUE(_(pc_a, pc_a));
  EXPECT_FALSE(_(pc_a, pc_b));
  EXPECT_TRUE(_(pc_b, pc_a));
  EXPECT_TRUE(_(pc_b, pc_b));
}