ReadMostlySharedPtrTest.cpp File Reference

#include <atomic>
#include <condition_variable>
#include <mutex>
#include <thread>
#include <folly/Memory.h>
#include <folly/experimental/ReadMostlySharedPtr.h>
#include <folly/portability/GTest.h>
#include <folly/synchronization/Baton.h>

Go to the source code of this file.

Classes
class	ReadMostlySharedPtrTest
class	TestObject
class	Coordinator
class	TestRefCount

Functions
	TEST_F (ReadMostlySharedPtrTest, BasicStores)
	TEST_F (ReadMostlySharedPtrTest, BasicLoads)
	TEST_F (ReadMostlySharedPtrTest, LoadsFromThreads)
	TEST_F (ReadMostlySharedPtrTest, Ctor)
	TEST_F (ReadMostlySharedPtrTest, ClearingCache)
	TEST_F (ReadMostlySharedPtrTest, ReadMostlyMainPtrDeleter)
	TEST_F (ReadMostlySharedPtrTest, nullptr)
	TEST_F (ReadMostlySharedPtrTest, getStdShared)

Variables
const unsigned int	TEST_TIMEOUT = 10
size_t	useGlobalCalls = 0

Function Documentation

TEST_F	(	ReadMostlySharedPtrTest	,
		BasicStores
	)

Definition at line 80 of file ReadMostlySharedPtrTest.cpp.

References EXPECT_EQ, ptr, and folly::ReadMostlyMainPtr< T, RefCount >::reset().

                                             {
  ReadMostlyMainPtr<TestObject> ptr;

  // Store 1.
  std::atomic<int> cnt1{0};
  ptr.reset(std::make_unique<TestObject>(1, cnt1));
  EXPECT_EQ(1, cnt1.load());

  // Store 2, check that 1 is destroyed.
  std::atomic<int> cnt2{0};
  ptr.reset(std::make_unique<TestObject>(2, cnt2));
  EXPECT_EQ(1, cnt2.load());
  EXPECT_EQ(0, cnt1.load());

  // Store nullptr, check that 2 is destroyed.
  ptr.reset(nullptr);
  EXPECT_EQ(0, cnt2.load());
}

TEST_F	(	ReadMostlySharedPtrTest	,
		BasicLoads
	)

Definition at line 99 of file ReadMostlySharedPtrTest.cpp.

References EXPECT_EQ, folly::ReadMostlyMainPtr< T, RefCount >::get(), ptr, folly::ReadMostlyMainPtr< T, RefCount >::reset(), folly::ReadMostlySharedPtr< T, RefCount >::reset(), and x.

                                            {
  std::atomic<int> cnt2{0};
  ReadMostlySharedPtr<TestObject> x;

  {
    ReadMostlyMainPtr<TestObject> ptr;

    // Check that ptr is initially nullptr.
    EXPECT_EQ(ptr.get(), nullptr);

    std::atomic<int> cnt1{0};
    ptr.reset(std::make_unique<TestObject>(1, cnt1));
    EXPECT_EQ(1, cnt1.load());

    x = ptr;
    EXPECT_EQ(1, x->value);

    ptr.reset(std::make_unique<TestObject>(2, cnt2));
    EXPECT_EQ(1, cnt2.load());
    EXPECT_EQ(1, cnt1.load());

    x = ptr;
    EXPECT_EQ(2, x->value);
    EXPECT_EQ(0, cnt1.load());

    ptr.reset(nullptr);
    EXPECT_EQ(1, cnt2.load());
  }

  EXPECT_EQ(1, cnt2.load());

  x.reset();
  EXPECT_EQ(0, cnt2.load());
}

TEST_F	(	ReadMostlySharedPtrTest	,
		LoadsFromThreads
	)

Definition at line 134 of file ReadMostlySharedPtrTest.cpp.

References Coordinator::completed(), EXPECT_EQ, folly::ReadMostlyMainPtr< T, RefCount >::getShared(), ptr, Coordinator::requestAndWait(), folly::ReadMostlyMainPtr< T, RefCount >::reset(), and Coordinator::waitForRequest().

                                                  {
  std::atomic<int> cnt{0};

  {
    ReadMostlyMainPtr<TestObject> ptr;
    Coordinator loads[7];

    std::thread t1([&] {
      loads[0].waitForRequest();
      EXPECT_EQ(ptr.getShared(), nullptr);
      loads[0].completed();

      loads[3].waitForRequest();
      EXPECT_EQ(2, ptr.getShared()->value);
      loads[3].completed();

      loads[4].waitForRequest();
      EXPECT_EQ(4, ptr.getShared()->value);
      loads[4].completed();

      loads[5].waitForRequest();
      EXPECT_EQ(5, ptr.getShared()->value);
      loads[5].completed();
    });

    std::thread t2([&] {
      loads[1].waitForRequest();
      EXPECT_EQ(1, ptr.getShared()->value);
      loads[1].completed();

      loads[2].waitForRequest();
      EXPECT_EQ(2, ptr.getShared()->value);
      loads[2].completed();

      loads[6].waitForRequest();
      EXPECT_EQ(5, ptr.getShared()->value);
      loads[6].completed();
    });

    loads[0].requestAndWait();

    ptr.reset(std::make_unique<TestObject>(1, cnt));
    loads[1].requestAndWait();

    ptr.reset(std::make_unique<TestObject>(2, cnt));
    loads[2].requestAndWait();
    loads[3].requestAndWait();

    ptr.reset(std::make_unique<TestObject>(3, cnt));
    ptr.reset(std::make_unique<TestObject>(4, cnt));
    loads[4].requestAndWait();

    ptr.reset(std::make_unique<TestObject>(5, cnt));
    loads[5].requestAndWait();
    loads[6].requestAndWait();

    EXPECT_EQ(1, cnt.load());

    t1.join();
    t2.join();
  }

  EXPECT_EQ(0, cnt.load());
}

TEST_F	(	ReadMostlySharedPtrTest	,
		Ctor
	)

Definition at line 199 of file ReadMostlySharedPtrTest.cpp.

References EXPECT_EQ, folly::ReadMostlyMainPtr< T, RefCount >::getShared(), and ptr.

                                      {
  std::atomic<int> cnt1{0};
  {
    ReadMostlyMainPtr<TestObject> ptr(std::make_unique<TestObject>(1, cnt1));

    EXPECT_EQ(1, ptr.getShared()->value);
  }

  EXPECT_EQ(0, cnt1.load());
}

TEST_F	(	ReadMostlySharedPtrTest	,
		ClearingCache
	)

Definition at line 210 of file ReadMostlySharedPtrTest.cpp.

References c, Coordinator::completed(), EXPECT_EQ, folly::ReadMostlyMainPtr< T, RefCount >::getShared(), ptr, Coordinator::requestAndWait(), folly::ReadMostlyMainPtr< T, RefCount >::reset(), folly::pushmi::detail::t, and Coordinator::waitForRequest().

                                               {
  std::atomic<int> cnt1{0};
  std::atomic<int> cnt2{0};

  ReadMostlyMainPtr<TestObject> ptr;

  // Store 1.
  ptr.reset(std::make_unique<TestObject>(1, cnt1));

  Coordinator c;

  std::thread t([&] {
    // Cache the pointer for this thread.
    ptr.getShared();
    c.requestAndWait();
  });

  // Wait for the thread to cache pointer.
  c.waitForRequest();
  EXPECT_EQ(1, cnt1.load());

  // Store 2 and check that 1 is destroyed.
  ptr.reset(std::make_unique<TestObject>(2, cnt2));
  EXPECT_EQ(0, cnt1.load());

  // Unblock thread.
  c.completed();
  t.join();
}

TEST_F	(	ReadMostlySharedPtrTest	,
		ReadMostlyMainPtrDeleter
	)

Definition at line 277 of file ReadMostlySharedPtrTest.cpp.

References folly::ReadMostlyMainPtrDeleter< RefCount >::add(), EXPECT_EQ, folly::gen::move, and useGlobalCalls.

                                                          {
  EXPECT_EQ(0, useGlobalCalls);
  {
    ReadMostlyMainPtr<int, TestRefCount> ptr1(std::make_shared<int>(42));
    ReadMostlyMainPtr<int, TestRefCount> ptr2(std::make_shared<int>(42));
  }

  EXPECT_EQ(4, useGlobalCalls);

  useGlobalCalls = 0;
  {
    ReadMostlyMainPtr<int, TestRefCount> ptr1(std::make_shared<int>(42));
    ReadMostlyMainPtr<int, TestRefCount> ptr2(std::make_shared<int>(42));

    ReadMostlyMainPtrDeleter<TestRefCount> deleter;
    deleter.add(std::move(ptr1));
    deleter.add(std::move(ptr2));
  }

  EXPECT_EQ(1, useGlobalCalls);
}

TEST_F	(	ReadMostlySharedPtrTest	,
		nullptr
	)

Definition at line 299 of file ReadMostlySharedPtrTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, EXPECT_TRUE, and ptr.

                                         {
  {
    ReadMostlyMainPtr<int, TestRefCount> nptr;
    EXPECT_TRUE(nptr == nullptr);
    EXPECT_TRUE(nullptr == nptr);
    EXPECT_EQ(nptr, nullptr);
    EXPECT_EQ(nullptr, nptr);
    EXPECT_FALSE(nptr);
    EXPECT_TRUE(!nptr);

    ReadMostlyMainPtr<int, TestRefCount> ptr(std::make_shared<int>(42));
    EXPECT_FALSE(ptr == nullptr);
    EXPECT_FALSE(nullptr == ptr);
    EXPECT_NE(ptr, nullptr);
    EXPECT_NE(nullptr, ptr);
    EXPECT_FALSE(!ptr);
    EXPECT_TRUE(ptr);
  }
  {
    ReadMostlySharedPtr<int, TestRefCount> nptr;
    EXPECT_TRUE(nptr == nullptr);
    EXPECT_TRUE(nullptr == nptr);
    EXPECT_EQ(nptr, nullptr);
    EXPECT_EQ(nullptr, nptr);
    EXPECT_FALSE(nptr);
    EXPECT_TRUE(!nptr);

    ReadMostlyMainPtr<int, TestRefCount> ptr(std::make_shared<int>(42));
    EXPECT_FALSE(ptr == nullptr);
    EXPECT_FALSE(nullptr == ptr);
    EXPECT_NE(ptr, nullptr);
    EXPECT_NE(nullptr, ptr);
    EXPECT_FALSE(!ptr);
    EXPECT_TRUE(ptr);
  }
}

TEST_F	(	ReadMostlySharedPtrTest	,
		getStdShared
	)

Definition at line 336 of file ReadMostlySharedPtrTest.cpp.

References folly::ReadMostlyMainPtr< T, RefCount >::getShared(), folly::ReadMostlyMainPtr< T, RefCount >::getStdShared(), folly::ReadMostlyMainPtr< T, RefCount >::reset(), and SUCCEED.

                                              {
  const ReadMostlyMainPtr<int> rmmp1(std::make_shared<int>(42));

  ReadMostlyMainPtr<int> rmmp2;
  rmmp2.reset(rmmp1.getStdShared());

  const ReadMostlySharedPtr<int> rmsp1 = rmmp1.getShared();
  ReadMostlySharedPtr<int> rmsp2(rmsp1);

  // No conditions to check; we just wanted to ensure this compiles.
  SUCCEED();
}

Variable Documentation

const unsigned int TEST_TIMEOUT = 10

Definition at line 34 of file ReadMostlySharedPtrTest.cpp.

Referenced by ReadMostlySharedPtrTest::ReadMostlySharedPtrTest().

size_t useGlobalCalls = 0

Definition at line 240 of file ReadMostlySharedPtrTest.cpp.

Referenced by TEST_F(), and TestRefCount::useGlobal().