SingletonTest.cpp File Reference

#include <thread>
#include <boost/thread/barrier.hpp>
#include <glog/logging.h>
#include <folly/Singleton.h>
#include <folly/experimental/io/FsUtil.h>
#include <folly/io/async/EventBase.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <folly/test/SingletonTestStructs.h>
#include <folly/Subprocess.h>

Go to the source code of this file.

Classes
struct	BasicUsageTag
struct	DirectUsageTag
struct	NamedUsageTag
struct	NaughtyUsageTag
struct	NaughtyUsageTag2
struct	SharedPtrUsageTag
struct	NeedyTag
struct	NeededSingleton
struct	NeedySingleton
struct	SelfNeedyTag
struct	SelfNeedySingleton
class	Slowpoke
struct	ConcurrencyTag
struct	ErrorConstructor
struct	CreationErrorTag
struct	ConcurrencyStressTag
struct	MockTag
struct	X
struct	ConcurrentCreationDestructionTag
struct	SlowpokeNeedySingleton
struct	MainThreadDestructorTag
struct	ThreadLoggingSingleton

Typedefs
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonBasicUsage = Singleton< T, Tag, BasicUsageTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonDirectUsage = Singleton< T, Tag, DirectUsageTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonNamedUsage = Singleton< T, Tag, NamedUsageTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonNaughtyUsage = Singleton< T, Tag, NaughtyUsageTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonNaughtyUsage2 = Singleton< T, Tag, NaughtyUsageTag2 >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonSharedPtrUsage = Singleton< T, Tag, SharedPtrUsageTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonNeedy = Singleton< T, Tag, NeedyTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonSelfNeedy = Singleton< T, Tag, SelfNeedyTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonConcurrency = Singleton< T, Tag, ConcurrencyTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonCreationError = Singleton< T, Tag, CreationErrorTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonConcurrencyStress = Singleton< T, Tag, ConcurrencyStressTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonEagerInitSync = Singleton< T, Tag, EagerInitSyncTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonEagerInitAsync = Singleton< T, Tag, EagerInitAsyncTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonEagerInitParallel = Singleton< T, Tag, EagerInitParallelTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonMock = Singleton< T, Tag, MockTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonConcurrentCreationDestruction = Singleton< T, Tag, ConcurrentCreationDestructionTag >
template<typename T , typename Tag = detail::DefaultTag>
using	SingletonMainThreadDestructor = Singleton< T, Tag, MainThreadDestructorTag >

Functions
	TEST (Singleton, MissingSingleton)
	TEST (Singleton, BasicUsage)
	TEST (Singleton, DirectUsage)
	TEST (Singleton, NamedUsage)
	TEST (Singleton, NaughtyUsage)
	TEST (Singleton, SharedPtrUsage)
	TEST (Singleton, SingletonDependencies)
	TEST (Singleton, SingletonConcurrency)
	TEST (Singleton, SingletonCreationError)
	TEST (Singleton, SingletonConcurrencyStress)
	TEST (Singleton, SingletonEagerInitSync)
	TEST (Singleton, SingletonEagerInitAsync)
	TEST (Singleton, SingletonEagerInitParallel)
	TEST (Singleton, MockTest)
	TEST (Singleton, DoubleRegistrationLogging)
	TEST (Singleton, CustomCreator)
	TEST (Singleton, ConcurrentCreationDestruction)
	TEST (Singleton, MainThreadDestructor)
	TEST (Singleton, DoubleMakeMockAfterTryGet)

Variables
folly::Singleton< X >	singleton_x ([](){return new X(42,"foo");})
folly::Baton	slowpokeNeedySingletonBaton

Typedef Documentation

template<typename T , typename Tag = detail::DefaultTag>

using SingletonBasicUsage = Singleton<T, Tag, BasicUsageTag>

Definition at line 44 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonConcurrency = Singleton<T, Tag, ConcurrencyTag>

Definition at line 365 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonConcurrencyStress = Singleton<T, Tag, ConcurrencyStressTag>

Definition at line 423 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonConcurrentCreationDestruction = Singleton<T, Tag, ConcurrentCreationDestructionTag>

Definition at line 666 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonCreationError = Singleton<T, Tag, CreationErrorTag>

Definition at line 407 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonDirectUsage = Singleton<T, Tag, DirectUsageTag>

Definition at line 88 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonEagerInitAsync = Singleton<T, Tag, EagerInitAsyncTag>

Definition at line 473 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonEagerInitParallel = Singleton<T, Tag, EagerInitParallelTag>

Definition at line 532 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonEagerInitSync = Singleton<T, Tag, EagerInitSyncTag>

Definition at line 453 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonMainThreadDestructor = Singleton<T, Tag, MainThreadDestructorTag>

Definition at line 699 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonMock = Singleton<T, Tag, MockTag>

Definition at line 584 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonNamedUsage = Singleton<T, Tag, NamedUsageTag>

Definition at line 113 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonNaughtyUsage = Singleton<T, Tag, NaughtyUsageTag>

Definition at line 155 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonNaughtyUsage2 = Singleton<T, Tag, NaughtyUsageTag2>

Definition at line 158 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonNeedy = Singleton<T, Tag, NeedyTag>

Definition at line 310 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonSelfNeedy = Singleton<T, Tag, SelfNeedyTag>

Definition at line 323 of file SingletonTest.cpp.

template<typename T , typename Tag = detail::DefaultTag>

using SingletonSharedPtrUsage = Singleton<T, Tag, SharedPtrUsageTag>

Definition at line 188 of file SingletonTest.cpp.

Function Documentation

TEST	(	Singleton	,
		MissingSingleton
	)

Definition at line 37 of file SingletonTest.cpp.

                                  {
  EXPECT_DEATH(
      []() { auto u = Singleton<UnregisteredWatchdog>::try_get(); }(), "");
}

TEST	(	Singleton	,
		BasicUsage
	)

Definition at line 49 of file SingletonTest.cpp.

References EXPECT_EQ, EXPECT_NE, folly::ReadMostlySharedPtr< T, RefCount >::get(), folly::Singleton< T, Tag, VaultTag >::try_get(), and folly::Singleton< T, Tag, VaultTag >::try_get_fast().

                            {
  auto& vault = *SingletonVault::singleton<BasicUsageTag>();

  EXPECT_EQ(vault.registeredSingletonCount(), 0);
  SingletonBasicUsage<Watchdog> watchdog_singleton;
  EXPECT_EQ(vault.registeredSingletonCount(), 1);

  SingletonBasicUsage<ChildWatchdog> child_watchdog_singleton;
  EXPECT_EQ(vault.registeredSingletonCount(), 2);

  vault.registrationComplete();

  // limit a scope to release references so we can destroy them later
  {
    std::shared_ptr<Watchdog> s1 = SingletonBasicUsage<Watchdog>::try_get();
    EXPECT_NE(s1, nullptr);

    std::shared_ptr<Watchdog> s2 = SingletonBasicUsage<Watchdog>::try_get();
    EXPECT_NE(s2, nullptr);

    EXPECT_EQ(s1, s2);
    EXPECT_EQ(s1.get(), SingletonBasicUsage<Watchdog>::try_get_fast().get());

    std::shared_ptr<ChildWatchdog> s3 =
        SingletonBasicUsage<ChildWatchdog>::try_get();
    EXPECT_NE(s3, nullptr);
    EXPECT_NE(s2, s3);

    EXPECT_EQ(vault.registeredSingletonCount(), 2);
    EXPECT_EQ(vault.livingSingletonCount(), 2);
  }

  vault.destroyInstances();
  EXPECT_EQ(vault.registeredSingletonCount(), 2);
  EXPECT_EQ(vault.livingSingletonCount(), 0);
}

TEST	(	Singleton	,
		DirectUsage
	)

Definition at line 90 of file SingletonTest.cpp.

References EXPECT_EQ, EXPECT_NE, and folly::Singleton< T, Tag, VaultTag >::try_get().

                             {
  auto& vault = *SingletonVault::singleton<DirectUsageTag>();

  EXPECT_EQ(vault.registeredSingletonCount(), 0);

  // Verify we can get to the underlying singletons via directly using
  // the singleton definition.
  SingletonDirectUsage<Watchdog> watchdog;
  struct TestTag {};
  SingletonDirectUsage<Watchdog, TestTag> named_watchdog;
  EXPECT_EQ(vault.registeredSingletonCount(), 2);
  vault.registrationComplete();

  EXPECT_NE(watchdog.try_get(), nullptr);
  EXPECT_EQ(watchdog.try_get(), SingletonDirectUsage<Watchdog>::try_get());
  EXPECT_NE(watchdog.try_get(), named_watchdog.try_get());
  EXPECT_EQ(watchdog.try_get()->livingWatchdogCount(), 2);

  vault.destroyInstances();
}

TEST	(	Singleton	,
		NamedUsage
	)

Definition at line 115 of file SingletonTest.cpp.

References EXPECT_EQ, EXPECT_NE, and folly::Singleton< T, Tag, VaultTag >::try_get().

                            {
  auto& vault = *SingletonVault::singleton<NamedUsageTag>();

  EXPECT_EQ(vault.registeredSingletonCount(), 0);

  // Define two named Watchdog singletons and one unnamed singleton.
  struct Watchdog1 {};
  struct Watchdog2 {};
  typedef detail::DefaultTag Watchdog3;
  SingletonNamedUsage<Watchdog, Watchdog1> watchdog1_singleton;
  EXPECT_EQ(vault.registeredSingletonCount(), 1);
  SingletonNamedUsage<Watchdog, Watchdog2> watchdog2_singleton;
  EXPECT_EQ(vault.registeredSingletonCount(), 2);
  SingletonNamedUsage<Watchdog, Watchdog3> watchdog3_singleton;
  EXPECT_EQ(vault.registeredSingletonCount(), 3);

  vault.registrationComplete();
  {
    // Verify our three singletons are distinct and non-nullptr.
    auto s1 = SingletonNamedUsage<Watchdog, Watchdog1>::try_get();
    EXPECT_EQ(s1, watchdog1_singleton.try_get());
    auto s2 = SingletonNamedUsage<Watchdog, Watchdog2>::try_get();
    EXPECT_EQ(s2, watchdog2_singleton.try_get());
    EXPECT_NE(s1, s2);
    auto s3 = SingletonNamedUsage<Watchdog, Watchdog3>::try_get();
    EXPECT_EQ(s3, watchdog3_singleton.try_get());
    EXPECT_NE(s3, s1);
    EXPECT_NE(s3, s2);

    // Verify the "default" singleton is the same as the DefaultTag-tagged
    // singleton.
    auto s4 = SingletonNamedUsage<Watchdog>::try_get();
    EXPECT_EQ(s4, watchdog3_singleton.try_get());
  }

  vault.destroyInstances();
}

TEST	(	Singleton	,
		NaughtyUsage
	)

Definition at line 162 of file SingletonTest.cpp.

                              {
  auto& vault = *SingletonVault::singleton<NaughtyUsageTag>();

  vault.registrationComplete();

  // Unregistered.
  EXPECT_DEATH(Singleton<Watchdog>::try_get(), "");
  EXPECT_DEATH(SingletonNaughtyUsage<Watchdog>::try_get(), "");

  vault.destroyInstances();

  auto& vault2 = *SingletonVault::singleton<NaughtyUsageTag2>();

  EXPECT_DEATH(SingletonNaughtyUsage2<Watchdog>::try_get(), "");
  SingletonNaughtyUsage2<Watchdog> watchdog_singleton;

  // double registration
  EXPECT_DEATH([]() { SingletonNaughtyUsage2<Watchdog> w2; }(), "");
  vault2.destroyInstances();

  // double registration after destroy
  EXPECT_DEATH([]() { SingletonNaughtyUsage2<Watchdog> w3; }(), "");
}

TEST	(	Singleton	,
		SharedPtrUsage
	)

Definition at line 191 of file SingletonTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, EXPECT_TRUE, folly::Singleton< T, Tag, VaultTag >::get_weak(), folly::kIsSanitizeAddress, folly::gen::move, now(), ptr, folly::pushmi::detail::t, and folly::Singleton< T, Tag, VaultTag >::try_get().

                                {
  struct WatchdogHolder {
    ~WatchdogHolder() {
      if (watchdog) {
        LOG(ERROR) << "The following log message with stack trace is expected";
      }
    }

    std::shared_ptr<Watchdog> watchdog;
  };

  auto& vault = *SingletonVault::singleton<SharedPtrUsageTag>();

  EXPECT_EQ(vault.registeredSingletonCount(), 0);
  std::vector<std::unique_ptr<Watchdog>> watchdog_instances;
  SingletonSharedPtrUsage<Watchdog> watchdog_singleton(
      [&] {
        watchdog_instances.push_back(std::make_unique<Watchdog>());
        return watchdog_instances.back().get();
      },
      [&](Watchdog* ptr) {
        // Make sure that only second instance is destroyed. First instance is
        // expected to be leaked.
        EXPECT_EQ(watchdog_instances[1].get(), ptr);
        watchdog_instances[1].reset();
      });
  EXPECT_EQ(vault.registeredSingletonCount(), 1);

  SingletonSharedPtrUsage<ChildWatchdog> child_watchdog_singleton;
  EXPECT_EQ(vault.registeredSingletonCount(), 2);

  struct ATag {};
  SingletonSharedPtrUsage<Watchdog, ATag> named_watchdog_singleton;

  SingletonSharedPtrUsage<WatchdogHolder> watchdog_holder_singleton;

  vault.registrationComplete();

  // Initilize holder singleton first, so that it's the last one to be
  // destroyed.
  watchdog_holder_singleton.try_get();

  auto s1 = SingletonSharedPtrUsage<Watchdog>::try_get().get();
  EXPECT_NE(s1, nullptr);

  auto s2 = SingletonSharedPtrUsage<Watchdog>::try_get().get();
  EXPECT_NE(s2, nullptr);

  EXPECT_EQ(s1, s2);

  auto weak_s1 = SingletonSharedPtrUsage<Watchdog>::get_weak();

  auto shared_s1 = weak_s1.lock();
  EXPECT_EQ(shared_s1.get(), s1);
  EXPECT_EQ(shared_s1.use_count(), 2);

  auto old_serial = shared_s1->serial_number;

  {
    auto named_weak_s1 = SingletonSharedPtrUsage<Watchdog, ATag>::get_weak();
    auto locked = named_weak_s1.lock();
    EXPECT_NE(locked.get(), shared_s1.get());
  }

  // We should release externally locked shared_ptr, otherwise it will be
  // considered a leak
  watchdog_holder_singleton.try_get()->watchdog = std::move(shared_s1);

  LOG(ERROR) << "The following log message regarding shared_ptr is expected";
  {
    auto start_time = std::chrono::steady_clock::now();
    vault.destroyInstances();
    auto duration = std::chrono::steady_clock::now() - start_time;
    EXPECT_TRUE(
        duration > std::chrono::seconds{4} &&
        duration < std::chrono::seconds{folly::kIsSanitizeAddress ? 30 : 6});
  }
  EXPECT_EQ(vault.registeredSingletonCount(), 4);
  EXPECT_EQ(vault.livingSingletonCount(), 0);

  EXPECT_TRUE(weak_s1.expired());

  auto empty_s1 = SingletonSharedPtrUsage<Watchdog>::get_weak();
  EXPECT_FALSE(empty_s1.lock());

  vault.reenableInstances();

  {
    // Singleton should be re-created only after reenableInstances() was called.
    auto new_s1 = SingletonSharedPtrUsage<Watchdog>::try_get();
    // Track serial number rather than pointer since the memory could be
    // re-used when we create new_s1.
    EXPECT_NE(new_s1->serial_number, old_serial);
  }

  auto new_s1_weak = SingletonSharedPtrUsage<Watchdog>::get_weak();
  auto new_s1_shared = new_s1_weak.lock();
  std::thread t([new_s1_shared]() mutable {
    std::this_thread::sleep_for(std::chrono::seconds{2});
    new_s1_shared.reset();
  });
  new_s1_shared.reset();
  {
    auto start_time = std::chrono::steady_clock::now();
    vault.destroyInstances();
    auto duration = std::chrono::steady_clock::now() - start_time;
    EXPECT_TRUE(
        duration > std::chrono::seconds{1} &&
        duration < std::chrono::seconds{3});
  }
  EXPECT_TRUE(new_s1_weak.expired());
  t.join();
}

TEST	(	Singleton	,
		SingletonDependencies
	)

Definition at line 332 of file SingletonTest.cpp.

References EXPECT_EQ, and folly::Singleton< T, Tag, VaultTag >::try_get().

                                       {
  SingletonNeedy<NeededSingleton> needed_singleton;
  SingletonNeedy<NeedySingleton> needy_singleton;
  auto& needy_vault = *SingletonVault::singleton<NeedyTag>();

  needy_vault.registrationComplete();

  EXPECT_EQ(needy_vault.registeredSingletonCount(), 2);
  EXPECT_EQ(needy_vault.livingSingletonCount(), 0);

  auto needy = SingletonNeedy<NeedySingleton>::try_get();
  EXPECT_EQ(needy_vault.livingSingletonCount(), 2);

  SingletonSelfNeedy<SelfNeedySingleton> self_needy_singleton;
  auto& self_needy_vault = *SingletonVault::singleton<SelfNeedyTag>();

  self_needy_vault.registrationComplete();
  EXPECT_DEATH(
      []() { SingletonSelfNeedy<SelfNeedySingleton>::try_get(); }(), "");
}

TEST	(	Singleton	,
		SingletonConcurrency
	)

Definition at line 367 of file SingletonTest.cpp.

References EXPECT_EQ, i, mutex, folly::pushmi::detail::t, threads, and folly::Singleton< T, Tag, VaultTag >::try_get().

                                      {
  auto& vault = *SingletonVault::singleton<ConcurrencyTag>();
  SingletonConcurrency<Slowpoke> slowpoke_singleton;
  vault.registrationComplete();

  std::mutex gatekeeper;
  gatekeeper.lock();
  auto func = [&gatekeeper]() {
    gatekeeper.lock();
    gatekeeper.unlock();
    auto unused = SingletonConcurrency<Slowpoke>::try_get();
  };

  EXPECT_EQ(vault.livingSingletonCount(), 0);
  std::vector<std::thread> threads;
  for (int i = 0; i < 100; ++i) {
    threads.emplace_back(func);
  }
  // If circular dependency checks fail, the unlock would trigger a
  // crash.  Instead, it succeeds, and we have exactly one living
  // singleton.
  gatekeeper.unlock();
  for (auto& t : threads) {
    t.join();
  }
  EXPECT_EQ(vault.livingSingletonCount(), 1);
}

TEST	(	Singleton	,
		SingletonCreationError
	)

Definition at line 409 of file SingletonTest.cpp.

References EXPECT_THROW, SUCCEED, and folly::Singleton< T, Tag, VaultTag >::try_get().

                                        {
  SingletonCreationError<ErrorConstructor> error_once_singleton;
  SingletonVault::singleton<CreationErrorTag>()->registrationComplete();

  // first time should error out
  EXPECT_THROW(error_once_singleton.try_get(), std::runtime_error);

  // second time it'll work fine
  error_once_singleton.try_get();
  SUCCEED();
}

TEST	(	Singleton	,
		SingletonConcurrencyStress
	)

Definition at line 425 of file SingletonTest.cpp.

References i, and folly::pushmi::detail::t.

                                            {
  auto& vault = *SingletonVault::singleton<ConcurrencyStressTag>();
  SingletonConcurrencyStress<Slowpoke> slowpoke_singleton;
  vault.registrationComplete();

  std::vector<std::thread> ts;
  for (size_t i = 0; i < 100; ++i) {
    ts.emplace_back([&]() { slowpoke_singleton.try_get(); });
  }

  for (size_t i = 0; i < 100; ++i) {
    std::chrono::milliseconds d(20);

    std::this_thread::sleep_for(d);
    vault.destroyInstances();
    std::this_thread::sleep_for(d);
    vault.destroyInstances();
  }

  for (auto& t : ts) {
    t.join();
  }
}

TEST	(	Singleton	,
		SingletonEagerInitSync
	)

Definition at line 454 of file SingletonTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and string.

                                        {
  auto& vault = *SingletonVault::singleton<EagerInitSyncTag>();
  bool didEagerInit = false;
  auto sing = SingletonEagerInitSync<std::string>([&] {
                didEagerInit = true;
                return new std::string("foo");
              })
                  .shouldEagerInit();
  vault.registrationComplete();
  EXPECT_FALSE(didEagerInit);
  vault.doEagerInit();
  EXPECT_TRUE(didEagerInit);
  sing.get_weak(); // (avoid compile error complaining about unused var 'sing')
}

TEST	(	Singleton	,
		SingletonEagerInitAsync
	)

Definition at line 474 of file SingletonTest.cpp.

References add, counter_, EXPECT_FALSE, EXPECT_TRUE, i, folly::EventBase::loop(), folly::gen::move, string, and folly::Baton< MayBlock, Atom >::wait().

                                         {
  auto& vault = *SingletonVault::singleton<EagerInitAsyncTag>();
  bool didEagerInit = false;
  auto sing = SingletonEagerInitAsync<std::string>([&] {
                didEagerInit = true;
                return new std::string("foo");
              })
                  .shouldEagerInit();
  folly::EventBase eb;
  folly::Baton<> done;
  vault.registrationComplete();
  EXPECT_FALSE(didEagerInit);
  vault.doEagerInitVia(eb, &done);
  eb.loop();
  done.wait();
  EXPECT_TRUE(didEagerInit);
  sing.get_weak(); // (avoid compile error complaining about unused var 'sing')
}

TEST	(	Singleton	,
		SingletonEagerInitParallel
	)

Definition at line 533 of file SingletonTest.cpp.

References exe, EXPECT_EQ, i, SCOPE_EXIT, string, and threads.

                                            {
  const static size_t kIters = 1000;
  const static size_t kThreads = 20;

  std::atomic<size_t> initCounter{0};

  auto& vault = *SingletonVault::singleton<EagerInitParallelTag>();

  auto sing = SingletonEagerInitParallel<std::string>([&] {
                ++initCounter;
                return new std::string("");
              })
                  .shouldEagerInit();

  for (size_t i = 0; i < kIters; i++) {
    SCOPE_EXIT {
      // clean up each time
      vault.destroyInstances();
      vault.reenableInstances();
    };

    initCounter.store(0);

    {
      std::vector<std::shared_ptr<std::thread>> threads;
      boost::barrier barrier(kThreads);
      TestEagerInitParallelExecutor exe(kThreads);
      vault.registrationComplete();

      EXPECT_EQ(0, initCounter.load());

      for (size_t j = 0; j < kThreads; j++) {
        threads.push_back(std::make_shared<std::thread>([&] {
          barrier.wait();
          vault.doEagerInitVia(exe);
        }));
      }

      for (auto thread : threads) {
        thread->join();
      }
    }

    EXPECT_EQ(1, initCounter.load());

    sing.get_weak(); // (avoid compile error complaining about unused var)
  }
}

TEST	(	Singleton	,
		MockTest
	)

Definition at line 588 of file SingletonTest.cpp.

References EXPECT_EQ, EXPECT_NE, folly::Singleton< T, Tag, VaultTag >::make_mock(), and folly::Singleton< T, Tag, VaultTag >::try_get().

                          {
  auto& vault = *SingletonVault::singleton<MockTag>();

  SingletonMock<Watchdog> watchdog_singleton;
  vault.registrationComplete();

  // Registring singletons after registrationComplete called works
  // with make_mock (but not with Singleton ctor).
  EXPECT_EQ(vault.registeredSingletonCount(), 1);
  int serial_count_first = SingletonMock<Watchdog>::try_get()->serial_number;

  // Override existing mock using make_mock.
  SingletonMock<Watchdog>::make_mock();

  EXPECT_EQ(vault.registeredSingletonCount(), 1);
  int serial_count_mock = SingletonMock<Watchdog>::try_get()->serial_number;

  // If serial_count value is the same, then singleton was not replaced.
  EXPECT_NE(serial_count_first, serial_count_mock);

  // Override existing mock using make_mock one more time
  SingletonMock<Watchdog>::make_mock();

  EXPECT_EQ(vault.registeredSingletonCount(), 1);
  int serial_count_mock2 = SingletonMock<Watchdog>::try_get()->serial_number;

  // If serial_count value is the same, then singleton was not replaced.
  EXPECT_NE(serial_count_first, serial_count_mock2);
  EXPECT_NE(serial_count_mock, serial_count_mock2);

  vault.destroyInstances();
}

TEST	(	Singleton	,
		DoubleRegistrationLogging
	)

Definition at line 623 of file SingletonTest.cpp.

References folly::Subprocess::Options::closeOtherFds(), folly::fs::executable_path(), EXPECT_EQ, EXPECT_THAT, folly::Subprocess::Options::pipeStderr(), testing::StartsWith(), folly::Subprocess::Options::stdinFd(), folly::Subprocess::Options::stdoutFd(), folly::gen::sub(), and gmock_test_utils::Subprocess.

                                           {
  const auto basename = "singleton_double_registration";
  const auto sub = fs::executable_path().remove_filename() / basename;
  auto p = Subprocess(
      std::vector<std::string>{sub.string()},
      Subprocess::Options()
          .stdinFd(Subprocess::CLOSE)
          .stdoutFd(Subprocess::CLOSE)
          .pipeStderr()
          .closeOtherFds());
  auto err = p.communicate("").second;
  auto res = p.wait();
  EXPECT_EQ(ProcessReturnCode::KILLED, res.state());
  EXPECT_EQ(SIGABRT, res.killSignal());
  EXPECT_THAT(err, testing::StartsWith("Double registration of singletons"));
}

TEST	(	Singleton	,
		CustomCreator
	)

Definition at line 653 of file SingletonTest.cpp.

References X::a1, X::a2, EXPECT_EQ, EXPECT_NE, singleton_x, and string.

                               {
  X x1;
  std::shared_ptr<X> x2p = singleton_x.try_get();
  EXPECT_NE(nullptr, x2p);
  EXPECT_NE(x1.a1, x2p->a1);
  EXPECT_NE(x1.a2, x2p->a2);
  EXPECT_EQ(42, x2p->a1);
  EXPECT_EQ(std::string("foo"), x2p->a2);
}

TEST	(	Singleton	,
		ConcurrentCreationDestruction
	)

Definition at line 681 of file SingletonTest.cpp.

References folly::Singleton< T, Tag, VaultTag >::try_get(), and folly::Baton< MayBlock, Atom >::wait().

                                               {
  auto& vault = *SingletonVault::singleton<ConcurrentCreationDestructionTag>();
  SingletonConcurrentCreationDestruction<NeededSingleton> neededSingleton;
  SingletonConcurrentCreationDestruction<SlowpokeNeedySingleton> needySingleton;
  vault.registrationComplete();

  std::thread needyThread([&] { needySingleton.try_get(); });

  slowpokeNeedySingletonBaton.wait();

  vault.destroyInstances();

  needyThread.join();
}

TEST	(	Singleton	,
		MainThreadDestructor
	)

Definition at line 716 of file SingletonTest.cpp.

References ThreadLoggingSingleton::destroyThread, EXPECT_EQ, ThreadLoggingSingleton::initThread, folly::singleton, and folly::pushmi::detail::t.

                                      {
  auto& vault = *SingletonVault::singleton<MainThreadDestructorTag>();
  SingletonMainThreadDestructor<ThreadLoggingSingleton> singleton;

  vault.registrationComplete();
  EXPECT_EQ(std::thread::id(), ThreadLoggingSingleton::initThread);

  singleton.try_get();
  EXPECT_EQ(std::this_thread::get_id(), ThreadLoggingSingleton::initThread);

  std::thread t([instance = singleton.try_get()] {
    /* sleep override */ std::this_thread::sleep_for(
        std::chrono::milliseconds{100});
  });

  EXPECT_EQ(std::thread::id(), ThreadLoggingSingleton::destroyThread);

  vault.destroyInstances();
  EXPECT_EQ(std::this_thread::get_id(), ThreadLoggingSingleton::destroyThread);

  t.join();
}

TEST	(	Singleton	,
		DoubleMakeMockAfterTryGet
	)

Definition at line 739 of file SingletonTest.cpp.

References EXPECT_EQ.

                                           {
  // to keep track of calls to ctor and dtor below
  struct Counts {
    size_t ctor = 0;
    size_t dtor = 0;
  };

  // a test type which keeps track of its ctor and dtor calls
  struct VaultTag {};
  struct PrivateTag {};
  struct Object {
    explicit Object(Counts& counts) : counts_(counts) {
      ++counts_.ctor;
    }
    ~Object() {
      ++counts_.dtor;
    }
    Counts& counts_;
  };
  using SingletonObject = Singleton<Object, PrivateTag, VaultTag>;

  // register everything
  Counts counts;
  auto& vault = *SingletonVault::singleton<VaultTag>();
  auto new_object = [&] { return new Object(counts); };
  SingletonObject object_(new_object);
  vault.registrationComplete();

  // no eager inits, nada (sanity)
  EXPECT_EQ(0, counts.ctor);
  EXPECT_EQ(0, counts.dtor);

  // explicit request, ctor
  SingletonObject::try_get();
  EXPECT_EQ(1, counts.ctor);
  EXPECT_EQ(0, counts.dtor);

  // first make_mock, dtor (ctor is lazy)
  SingletonObject::make_mock(new_object);
  EXPECT_EQ(1, counts.ctor);
  EXPECT_EQ(1, counts.dtor);

  // second make_mock, nada (dtor already ran, ctor is lazy)
  SingletonObject::make_mock(new_object);
  EXPECT_EQ(1, counts.ctor);
  EXPECT_EQ(1, counts.dtor);
}

Variable Documentation

folly::Singleton<X> singleton_x([](){return new X(42,"foo");})

Referenced by TEST().

folly::Baton slowpokeNeedySingletonBaton

Definition at line 668 of file SingletonTest.cpp.