ArenaSmartPtrTest.cpp File Reference

#include <folly/Memory.h>
#include <folly/memory/Arena.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	global_counter
class	Foo

Functions
template<typename Allocator >
void	unique_ptr_test (Allocator &allocator)
	TEST (ArenaSmartPtr, unique_ptr_SysArena)
template<typename Allocator >
void	shared_ptr_test (Allocator &allocator)
	TEST (ArenaSmartPtr, shared_ptr_SysArena)
int	main (int argc, char *argv[])

Function Documentation

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 166 of file ArenaSmartPtrTest.cpp.

References testing::InitGoogleTest(), and RUN_ALL_TESTS().

                                 {
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

template<typename Allocator >

void shared_ptr_test

(

Allocator &

allocator

)

Definition at line 106 of file ArenaSmartPtrTest.cpp.

References global_counter::count(), counter, EXPECT_EQ, folly::foo, and g().

Referenced by TEST().

                                           {
  typedef std::shared_ptr<Foo> ptr_type;

  global_counter counter;
  EXPECT_EQ(counter.count(), 0);

  ptr_type foo;
  EXPECT_EQ(counter.count(), 0);
  EXPECT_EQ(foo.use_count(), 0);

  {
    auto p = std::allocate_shared<Foo>(allocator, counter);
    EXPECT_EQ(counter.count(), 1);
    EXPECT_EQ(p.use_count(), 1);

    p.reset();
    EXPECT_EQ(counter.count(), 0);
    EXPECT_EQ(p.use_count(), 0);

    p = std::allocate_shared<Foo>(allocator, counter);
    EXPECT_EQ(counter.count(), 1);
    EXPECT_EQ(p.use_count(), 1);

    foo = p;
    EXPECT_EQ(p.use_count(), 2);
  }
  EXPECT_EQ(counter.count(), 1);
  EXPECT_EQ(foo.use_count(), 1);

  {
    auto p = foo;
    EXPECT_EQ(counter.count(), 1);
    EXPECT_EQ(p.use_count(), 2);

    [&](ptr_type g) {
      EXPECT_EQ(counter.count(), 1);
      EXPECT_EQ(p.use_count(), 3);
      EXPECT_EQ(g.use_count(), 3);
      g.reset();
      EXPECT_EQ(counter.count(), 1);
      EXPECT_EQ(p.use_count(), 2);
      EXPECT_EQ(g.use_count(), 0);
    }(p);
    EXPECT_EQ(counter.count(), 1);
    EXPECT_EQ(p.use_count(), 2);
  }
  EXPECT_EQ(counter.count(), 1);
  EXPECT_EQ(foo.use_count(), 1);

  foo.reset();
  EXPECT_EQ(counter.count(), 0);
  EXPECT_EQ(foo.use_count(), 0);
}

TEST	(	ArenaSmartPtr	,
		unique_ptr_SysArena
	)

Definition at line 99 of file ArenaSmartPtrTest.cpp.

References unique_ptr_test().

                                         {
  SysArena arena;
  SysArenaAllocator<Foo> alloc(arena);
  unique_ptr_test(alloc);
}

TEST	(	ArenaSmartPtr	,
		shared_ptr_SysArena
	)

Definition at line 160 of file ArenaSmartPtrTest.cpp.

References shared_ptr_test().

                                         {
  SysArena arena;
  SysArenaAllocator<Foo> alloc(arena);
  shared_ptr_test(alloc);
}

template<typename Allocator >

void unique_ptr_test

(

Allocator &

allocator

)

Definition at line 60 of file ArenaSmartPtrTest.cpp.

References global_counter::count(), counter, destroy(), EXPECT_EQ, g(), and folly::gen::move.

Referenced by TEST().

                                           {
  using ptr_type = std::unique_ptr<Foo, allocator_delete<Allocator>>;

  global_counter counter;
  EXPECT_EQ(counter.count(), 0);

  Foo* foo = nullptr;

  {
    auto p = folly::allocate_unique<Foo>(allocator, counter);
    EXPECT_EQ(counter.count(), 1);

    p.reset();
    EXPECT_EQ(counter.count(), 0);

    p = folly::allocate_unique<Foo>(allocator, counter);
    EXPECT_EQ(counter.count(), 1);

    foo = p.release();
    EXPECT_EQ(counter.count(), 1);
  }
  EXPECT_EQ(counter.count(), 1);

  {
    auto p = folly::allocate_unique<Foo>(allocator, counter);
    EXPECT_EQ(counter.count(), 2);

    [&](ptr_type g) {
      EXPECT_EQ(counter.count(), 2);
      g.reset();
      EXPECT_EQ(counter.count(), 1);
    }(std::move(p));
  }
  EXPECT_EQ(counter.count(), 1);

  std::allocator_traits<Allocator>::destroy(allocator, foo);
  EXPECT_EQ(counter.count(), 0);
}