IndestructibleTest.cpp File Reference

#include <folly/Indestructible.h>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <tuple>
#include <folly/Memory.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST_F (IndestructibleTest, access)
	TEST_F (IndestructibleTest, no_destruction)
	TEST_F (IndestructibleTest, empty)
	TEST_F (IndestructibleTest, move)
	TEST_F (IndestructibleTest, disabled_default_ctor)
	TEST_F (IndestructibleTest, list_initialization)
	TEST_F (IndestructibleTest, initializer_list_in_place_initialization)
	TEST_F (IndestructibleTest, list_initialization_explicit_implicit)

Function Documentation

TEST_F	(	IndestructibleTest	,
		access
	)

Definition at line 57 of file IndestructibleTest.cpp.

References data, EXPECT_EQ, and m.

                                   {
  static const Indestructible<map<string, int>> data{
      map<string, int>{{"key1", 17}, {"key2", 19}, {"key3", 23}}};

  auto& m = *data;
  EXPECT_EQ(19, m.at("key2"));
}

TEST_F	(	IndestructibleTest	,
		no_destruction
	)

Definition at line 65 of file IndestructibleTest.cpp.

References EXPECT_EQ, and value.

                                           {
  int state = 0;
  int value = 0;

  static Indestructible<Magic> sing(
      [&] {
        ++state;
        value = 7;
      },
      [&] { state = -1; },
      [] {});
  EXPECT_EQ(1, state);
  EXPECT_EQ(7, value);

  sing.~Indestructible();
  EXPECT_EQ(1, state);
}

TEST_F	(	IndestructibleTest	,
		empty
	)

Definition at line 83 of file IndestructibleTest.cpp.

References data, EXPECT_EQ, and m.

                                  {
  static const Indestructible<map<string, int>> data;
  auto& m = *data;
  EXPECT_EQ(0, m.size());
}

TEST_F	(	IndestructibleTest	,
		move
	)

Definition at line 89 of file IndestructibleTest.cpp.

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

                                 {
  int state = 0;
  int value = 0;
  int moves = 0;

  static Indestructible<Magic> sing( // move assignment
      [&] {
        ++state;
        value = 7;
      },
      [&] { state = -1; },
      [&] { ++moves; });

  EXPECT_EQ(1, state);
  EXPECT_EQ(7, value);
  EXPECT_EQ(0, moves);

  // move constructor
  static Indestructible<Magic> move_ctor(std::move(sing));
  EXPECT_EQ(1, state);
  EXPECT_EQ(1, moves);

  // move assignment
  static Indestructible<Magic> move_assign = std::move(move_ctor);
  EXPECT_EQ(1, state);
  EXPECT_EQ(2, moves);
}

TEST_F	(	IndestructibleTest	,
		disabled_default_ctor
	)

Definition at line 117 of file IndestructibleTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and value.

                                                  {
  EXPECT_TRUE((std::is_constructible<Indestructible<int>>::value)) << "sanity";

  struct Foo {
    Foo(int) {}
  };
  EXPECT_FALSE((std::is_constructible<Indestructible<Foo>>::value));
  EXPECT_FALSE((std::is_constructible<Indestructible<Foo>, Magic>::value));
  EXPECT_TRUE((std::is_constructible<Indestructible<Foo>, int>::value));
}

TEST_F	(	IndestructibleTest	,
		list_initialization
	)

Definition at line 128 of file IndestructibleTest.cpp.

References EXPECT_EQ, and map().

                                                {
  auto map = folly::Indestructible<std::map<int, int>>{{{1, 2}}};
  EXPECT_EQ(map->at(1), 2);
}

TEST_F	(	IndestructibleTest	,
		initializer_list_in_place_initialization
	)

Definition at line 142 of file IndestructibleTest.cpp.

                                                                     {
  using I = InitializerListConstructible;
  std::ignore = Indestructible<I>{{1, 2, 3, 4}};
  std::ignore = Indestructible<I>{{1.2}, 4.2};
}

TEST_F	(	IndestructibleTest	,
		list_initialization_explicit_implicit
	)

Definition at line 156 of file IndestructibleTest.cpp.

References EXPECT_TRUE, and value.

                                                                  {
  using E = ExplicitlyMoveConstructible;
  using I = std::map<int, int>;
  EXPECT_TRUE((!std::is_convertible<E, Indestructible<E>>::value));
  EXPECT_TRUE((std::is_convertible<I, Indestructible<I>>::value));
}