folly/test/SingletonTest.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <thread>
  18
  19 #include <folly/Singleton.h>
  20 #include <folly/experimental/io/FsUtil.h>
  21 #include <folly/io/async/EventBase.h>
  22 #include <folly/portability/GMock.h>
  23 #include <folly/portability/GTest.h>
  24 #include <folly/test/SingletonTestStructs.h>
  25
  26 #ifndef _MSC_VER
  27 #include <folly/Subprocess.h>
  28 #endif
  29
  30 #include <glog/logging.h>
  31 #include <boost/thread/barrier.hpp>
  32
  33 FOLLY_GCC_DISABLE_WARNING("-Wdeprecated-declarations")
  34
  35 using namespace folly;
  36
  37 TEST(Singleton, MissingSingleton) {
  38   EXPECT_DEATH([]() { auto u = Singleton<UnregisteredWatchdog>::try_get(); }(),
  39       "");
  40 }
  41
  42 struct BasicUsageTag {};
  43 template <typename T, typename Tag = detail::DefaultTag>
  44 using SingletonBasicUsage = Singleton <T, Tag, BasicUsageTag>;
  45
  46 // Exercise some basic codepaths ensuring registration order and
  47 // destruction order happen as expected, that instances are created
  48 // when expected, etc etc.
  49 TEST(Singleton, BasicUsage) {
  50   auto& vault = *SingletonVault::singleton<BasicUsageTag>();
  51
  52   EXPECT_EQ(vault.registeredSingletonCount(), 0);
  53   SingletonBasicUsage<Watchdog> watchdog_singleton;
  54   EXPECT_EQ(vault.registeredSingletonCount(), 1);
  55
  56   SingletonBasicUsage<ChildWatchdog> child_watchdog_singleton;
  57   EXPECT_EQ(vault.registeredSingletonCount(), 2);
  58
  59   vault.registrationComplete();
  60
  61   // limit a scope to release references so we can destroy them later
  62   {
  63     std::shared_ptr<Watchdog> s1 = SingletonBasicUsage<Watchdog>::try_get();
  64     EXPECT_NE(s1, nullptr);
  65
  66     std::shared_ptr<Watchdog> s2 = SingletonBasicUsage<Watchdog>::try_get();
  67     EXPECT_NE(s2, nullptr);
  68
  69     EXPECT_EQ(s1, s2);
  70     EXPECT_EQ(s1.get(), SingletonBasicUsage<Watchdog>::try_get_fast().get());
  71
  72     std::shared_ptr<ChildWatchdog> s3 =
  73       SingletonBasicUsage<ChildWatchdog>::try_get();
  74     EXPECT_NE(s3, nullptr);
  75     EXPECT_NE(s2, s3);
  76
  77     EXPECT_EQ(vault.registeredSingletonCount(), 2);
  78     EXPECT_EQ(vault.livingSingletonCount(), 2);
  79   }
  80
  81   vault.destroyInstances();
  82   EXPECT_EQ(vault.registeredSingletonCount(), 2);
  83   EXPECT_EQ(vault.livingSingletonCount(), 0);
  84 }
  85
  86 struct DirectUsageTag {};
  87 template <typename T, typename Tag = detail::DefaultTag>
  88 using SingletonDirectUsage = Singleton <T, Tag, DirectUsageTag>;
  89
  90 TEST(Singleton, DirectUsage) {
  91   auto& vault = *SingletonVault::singleton<DirectUsageTag>();
  92
  93   EXPECT_EQ(vault.registeredSingletonCount(), 0);
  94
  95   // Verify we can get to the underlying singletons via directly using
  96   // the singleton definition.
  97   SingletonDirectUsage<Watchdog> watchdog;
  98   struct TestTag {};
  99   SingletonDirectUsage<Watchdog, TestTag> named_watchdog;
 100   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 101   vault.registrationComplete();
 102
 103   EXPECT_NE(watchdog.try_get(), nullptr);
 104   EXPECT_EQ(watchdog.try_get(), SingletonDirectUsage<Watchdog>::try_get());
 105   EXPECT_NE(watchdog.try_get(), named_watchdog.try_get());
 106   EXPECT_EQ(watchdog.try_get()->livingWatchdogCount(), 2);
 107
 108   vault.destroyInstances();
 109 }
 110
 111 struct NamedUsageTag {};
 112 template <typename T, typename Tag = detail::DefaultTag>
 113 using SingletonNamedUsage = Singleton <T, Tag, NamedUsageTag>;
 114
 115 TEST(Singleton, NamedUsage) {
 116   auto& vault = *SingletonVault::singleton<NamedUsageTag>();
 117
 118   EXPECT_EQ(vault.registeredSingletonCount(), 0);
 119
 120   // Define two named Watchdog singletons and one unnamed singleton.
 121   struct Watchdog1 {};
 122   struct Watchdog2 {};
 123   typedef detail::DefaultTag Watchdog3;
 124   SingletonNamedUsage<Watchdog, Watchdog1> watchdog1_singleton;
 125   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 126   SingletonNamedUsage<Watchdog, Watchdog2> watchdog2_singleton;
 127   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 128   SingletonNamedUsage<Watchdog, Watchdog3> watchdog3_singleton;
 129   EXPECT_EQ(vault.registeredSingletonCount(), 3);
 130
 131   vault.registrationComplete();
 132   {
 133     // Verify our three singletons are distinct and non-nullptr.
 134     auto s1 = SingletonNamedUsage<Watchdog, Watchdog1>::try_get();
 135     EXPECT_EQ(s1, watchdog1_singleton.try_get());
 136     auto s2 = SingletonNamedUsage<Watchdog, Watchdog2>::try_get();
 137     EXPECT_EQ(s2, watchdog2_singleton.try_get());
 138     EXPECT_NE(s1, s2);
 139     auto s3 = SingletonNamedUsage<Watchdog, Watchdog3>::try_get();
 140     EXPECT_EQ(s3, watchdog3_singleton.try_get());
 141     EXPECT_NE(s3, s1);
 142     EXPECT_NE(s3, s2);
 143
 144     // Verify the "default" singleton is the same as the DefaultTag-tagged
 145     // singleton.
 146     auto s4 = SingletonNamedUsage<Watchdog>::try_get();
 147     EXPECT_EQ(s4, watchdog3_singleton.try_get());
 148   }
 149
 150   vault.destroyInstances();
 151 }
 152
 153 struct NaughtyUsageTag {};
 154 template <typename T, typename Tag = detail::DefaultTag>
 155 using SingletonNaughtyUsage = Singleton <T, Tag, NaughtyUsageTag>;
 156 struct NaughtyUsageTag2 {};
 157 template <typename T, typename Tag = detail::DefaultTag>
 158 using SingletonNaughtyUsage2 = Singleton <T, Tag, NaughtyUsageTag2>;
 159
 160 // Some pathological cases such as getting unregistered singletons,
 161 // double registration, etc.
 162 TEST(Singleton, NaughtyUsage) {
 163   auto& vault = *SingletonVault::singleton<NaughtyUsageTag>();
 164
 165   vault.registrationComplete();
 166
 167   // Unregistered.
 168   EXPECT_DEATH(Singleton<Watchdog>::try_get(), "");
 169   EXPECT_DEATH(SingletonNaughtyUsage<Watchdog>::try_get(), "");
 170
 171   vault.destroyInstances();
 172
 173   auto& vault2 = *SingletonVault::singleton<NaughtyUsageTag2>();
 174
 175    EXPECT_DEATH(SingletonNaughtyUsage2<Watchdog>::try_get(), "");
 176   SingletonNaughtyUsage2<Watchdog> watchdog_singleton;
 177
 178   // double registration
 179   EXPECT_DEATH([]() { SingletonNaughtyUsage2<Watchdog> w2; }(), "");
 180   vault2.destroyInstances();
 181
 182   // double registration after destroy
 183   EXPECT_DEATH([]() { SingletonNaughtyUsage2<Watchdog> w3; }(), "");
 184 }
 185
 186 struct SharedPtrUsageTag {};
 187 template <typename T, typename Tag = detail::DefaultTag>
 188 using SingletonSharedPtrUsage = Singleton <T, Tag, SharedPtrUsageTag>;
 189
 190 // TODO (anob): revisit this test
 191 TEST(Singleton, SharedPtrUsage) {
 192   struct WatchdogHolder {
 193     ~WatchdogHolder() {
 194       if (watchdog) {
 195         LOG(ERROR) << "The following log message with stack trace is expected";
 196       }
 197     }
 198
 199     std::shared_ptr<Watchdog> watchdog;
 200   };
 201
 202   auto& vault = *SingletonVault::singleton<SharedPtrUsageTag>();
 203
 204   EXPECT_EQ(vault.registeredSingletonCount(), 0);
 205   SingletonSharedPtrUsage<Watchdog> watchdog_singleton;
 206   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 207
 208   SingletonSharedPtrUsage<ChildWatchdog> child_watchdog_singleton;
 209   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 210
 211   struct ATag {};
 212   SingletonSharedPtrUsage<Watchdog, ATag> named_watchdog_singleton;
 213
 214   SingletonSharedPtrUsage<WatchdogHolder> watchdog_holder_singleton;
 215
 216   vault.registrationComplete();
 217
 218   // Initilize holder singleton first, so that it's the last one to be
 219   // destroyed.
 220   watchdog_holder_singleton.try_get();
 221
 222   auto s1 = SingletonSharedPtrUsage<Watchdog>::try_get().get();
 223   EXPECT_NE(s1, nullptr);
 224
 225   auto s2 = SingletonSharedPtrUsage<Watchdog>::try_get().get();
 226   EXPECT_NE(s2, nullptr);
 227
 228   EXPECT_EQ(s1, s2);
 229
 230   auto weak_s1 = SingletonSharedPtrUsage<Watchdog>::get_weak();
 231
 232   auto shared_s1 = weak_s1.lock();
 233   EXPECT_EQ(shared_s1.get(), s1);
 234   EXPECT_EQ(shared_s1.use_count(), 2);
 235
 236   auto old_serial = shared_s1->serial_number;
 237
 238   {
 239     auto named_weak_s1 =
 240       SingletonSharedPtrUsage<Watchdog, ATag>::get_weak();
 241     auto locked = named_weak_s1.lock();
 242     EXPECT_NE(locked.get(), shared_s1.get());
 243   }
 244
 245   // We should release externally locked shared_ptr, otherwise it will be
 246   // considered a leak
 247   watchdog_holder_singleton.try_get()->watchdog = std::move(shared_s1);
 248
 249   LOG(ERROR) << "The following log message regarding shared_ptr is expected";
 250   {
 251     auto start_time = std::chrono::steady_clock::now();
 252     vault.destroyInstances();
 253     auto duration = std::chrono::steady_clock::now() - start_time;
 254     EXPECT_TRUE(duration > std::chrono::seconds{4} &&
 255                 duration < std::chrono::seconds{6});
 256   }
 257   EXPECT_EQ(vault.registeredSingletonCount(), 4);
 258   EXPECT_EQ(vault.livingSingletonCount(), 0);
 259
 260   EXPECT_TRUE(weak_s1.expired());
 261
 262   auto empty_s1 = SingletonSharedPtrUsage<Watchdog>::get_weak();
 263   EXPECT_FALSE(empty_s1.lock());
 264
 265   vault.reenableInstances();
 266
 267   {
 268     // Singleton should be re-created only after reenableInstances() was called.
 269     auto new_s1 = SingletonSharedPtrUsage<Watchdog>::try_get();
 270     // Track serial number rather than pointer since the memory could be
 271     // re-used when we create new_s1.
 272     EXPECT_NE(new_s1->serial_number, old_serial);
 273   }
 274
 275   auto new_s1_weak = SingletonSharedPtrUsage<Watchdog>::get_weak();
 276   auto new_s1_shared = new_s1_weak.lock();
 277   std::thread t([new_s1_shared]() mutable {
 278       std::this_thread::sleep_for(std::chrono::seconds{2});
 279       new_s1_shared.reset();
 280     });
 281   new_s1_shared.reset();
 282   {
 283     auto start_time = std::chrono::steady_clock::now();
 284     vault.destroyInstances();
 285     auto duration = std::chrono::steady_clock::now() - start_time;
 286     EXPECT_TRUE(duration > std::chrono::seconds{1} &&
 287                 duration < std::chrono::seconds{3});
 288   }
 289   EXPECT_TRUE(new_s1_weak.expired());
 290   t.join();
 291 }
 292
 293 // Some classes to test singleton dependencies.  NeedySingleton has a
 294 // dependency on NeededSingleton, which happens during its
 295 // construction.
 296 struct NeedyTag {};
 297 template <typename T, typename Tag = detail::DefaultTag>
 298 using SingletonNeedy = Singleton <T, Tag, NeedyTag>;
 299
 300 struct NeededSingleton {};
 301 struct NeedySingleton {
 302   NeedySingleton() {
 303     auto unused = SingletonNeedy<NeededSingleton>::try_get();
 304     EXPECT_NE(unused, nullptr);
 305   }
 306 };
 307
 308 // Ensure circular dependencies fail -- a singleton that needs itself, whoops.
 309 struct SelfNeedyTag {};
 310 template <typename T, typename Tag = detail::DefaultTag>
 311 using SingletonSelfNeedy = Singleton <T, Tag, SelfNeedyTag>;
 312
 313 struct SelfNeedySingleton {
 314   SelfNeedySingleton() {
 315     auto unused = SingletonSelfNeedy<SelfNeedySingleton>::try_get();
 316     EXPECT_NE(unused, nullptr);
 317   }
 318 };
 319
 320 TEST(Singleton, SingletonDependencies) {
 321   SingletonNeedy<NeededSingleton> needed_singleton;
 322   SingletonNeedy<NeedySingleton> needy_singleton;
 323   auto& needy_vault = *SingletonVault::singleton<NeedyTag>();
 324
 325   needy_vault.registrationComplete();
 326
 327   EXPECT_EQ(needy_vault.registeredSingletonCount(), 2);
 328   EXPECT_EQ(needy_vault.livingSingletonCount(), 0);
 329
 330   auto needy = SingletonNeedy<NeedySingleton>::try_get();
 331   EXPECT_EQ(needy_vault.livingSingletonCount(), 2);
 332
 333   SingletonSelfNeedy<SelfNeedySingleton> self_needy_singleton;
 334   auto& self_needy_vault = *SingletonVault::singleton<SelfNeedyTag>();
 335
 336   self_needy_vault.registrationComplete();
 337   EXPECT_DEATH([]() { SingletonSelfNeedy<SelfNeedySingleton>::try_get(); }(),
 338       "");
 339 }
 340
 341 // A test to ensure multiple threads contending on singleton creation
 342 // properly wait for creation rather than thinking it is a circular
 343 // dependency.
 344 class Slowpoke : public Watchdog {
 345  public:
 346   Slowpoke() { std::this_thread::sleep_for(std::chrono::milliseconds(10)); }
 347 };
 348
 349 struct ConcurrencyTag {};
 350 template <typename T, typename Tag = detail::DefaultTag>
 351 using SingletonConcurrency = Singleton <T, Tag, ConcurrencyTag>;
 352
 353 TEST(Singleton, SingletonConcurrency) {
 354   auto& vault = *SingletonVault::singleton<ConcurrencyTag>();
 355   SingletonConcurrency<Slowpoke> slowpoke_singleton;
 356   vault.registrationComplete();
 357
 358   std::mutex gatekeeper;
 359   gatekeeper.lock();
 360   auto func = [&gatekeeper]() {
 361     gatekeeper.lock();
 362     gatekeeper.unlock();
 363     auto unused = SingletonConcurrency<Slowpoke>::try_get();
 364   };
 365
 366   EXPECT_EQ(vault.livingSingletonCount(), 0);
 367   std::vector<std::thread> threads;
 368   for (int i = 0; i < 100; ++i) {
 369     threads.emplace_back(func);
 370   }
 371   // If circular dependency checks fail, the unlock would trigger a
 372   // crash.  Instead, it succeeds, and we have exactly one living
 373   // singleton.
 374   gatekeeper.unlock();
 375   for (auto& t : threads) {
 376     t.join();
 377   }
 378   EXPECT_EQ(vault.livingSingletonCount(), 1);
 379 }
 380
 381 struct ErrorConstructor {
 382   static size_t constructCount_;
 383   ErrorConstructor() {
 384     if ((constructCount_++) == 0) {
 385       throw std::runtime_error("first time fails");
 386     }
 387   }
 388 };
 389 size_t ErrorConstructor::constructCount_(0);
 390
 391 struct CreationErrorTag {};
 392 template <typename T, typename Tag = detail::DefaultTag>
 393 using SingletonCreationError = Singleton<T, Tag, CreationErrorTag>;
 394
 395 TEST(Singleton, SingletonCreationError) {
 396   SingletonCreationError<ErrorConstructor> error_once_singleton;
 397   SingletonVault::singleton<CreationErrorTag>()->registrationComplete();
 398
 399   // first time should error out
 400   EXPECT_THROW(error_once_singleton.try_get(), std::runtime_error);
 401
 402   // second time it'll work fine
 403   error_once_singleton.try_get();
 404   SUCCEED();
 405 }
 406
 407 struct ConcurrencyStressTag {};
 408 template <typename T, typename Tag = detail::DefaultTag>
 409 using SingletonConcurrencyStress = Singleton <T, Tag, ConcurrencyStressTag>;
 410
 411 TEST(Singleton, SingletonConcurrencyStress) {
 412   auto& vault = *SingletonVault::singleton<ConcurrencyStressTag>();
 413   SingletonConcurrencyStress<Slowpoke> slowpoke_singleton;
 414   vault.registrationComplete();
 415
 416   std::vector<std::thread> ts;
 417   for (size_t i = 0; i < 100; ++i) {
 418     ts.emplace_back([&]() {
 419         slowpoke_singleton.try_get();
 420       });
 421   }
 422
 423   for (size_t i = 0; i < 100; ++i) {
 424     std::chrono::milliseconds d(20);
 425
 426     std::this_thread::sleep_for(d);
 427     vault.destroyInstances();
 428     std::this_thread::sleep_for(d);
 429     vault.destroyInstances();
 430   }
 431
 432   for (auto& t : ts) {
 433     t.join();
 434   }
 435 }
 436
 437 namespace {
 438 struct EagerInitSyncTag {};
 439 }
 440 template <typename T, typename Tag = detail::DefaultTag>
 441 using SingletonEagerInitSync = Singleton<T, Tag, EagerInitSyncTag>;
 442 TEST(Singleton, SingletonEagerInitSync) {
 443   auto& vault = *SingletonVault::singleton<EagerInitSyncTag>();
 444   bool didEagerInit = false;
 445   auto sing = SingletonEagerInitSync<std::string>(
 446                   [&] {didEagerInit = true; return new std::string("foo"); })
 447               .shouldEagerInit();
 448   vault.registrationComplete();
 449   EXPECT_FALSE(didEagerInit);
 450   vault.doEagerInit();
 451   EXPECT_TRUE(didEagerInit);
 452   sing.get_weak();  // (avoid compile error complaining about unused var 'sing')
 453 }
 454
 455 namespace {
 456 struct EagerInitAsyncTag {};
 457 }
 458 template <typename T, typename Tag = detail::DefaultTag>
 459 using SingletonEagerInitAsync = Singleton<T, Tag, EagerInitAsyncTag>;
 460 TEST(Singleton, SingletonEagerInitAsync) {
 461   auto& vault = *SingletonVault::singleton<EagerInitAsyncTag>();
 462   bool didEagerInit = false;
 463   auto sing = SingletonEagerInitAsync<std::string>(
 464                   [&] {didEagerInit = true; return new std::string("foo"); })
 465               .shouldEagerInit();
 466   folly::EventBase eb;
 467   folly::Baton<> done;
 468   vault.registrationComplete();
 469   EXPECT_FALSE(didEagerInit);
 470   vault.doEagerInitVia(eb, &done);
 471   eb.loop();
 472   done.wait();
 473   EXPECT_TRUE(didEagerInit);
 474   sing.get_weak();  // (avoid compile error complaining about unused var 'sing')
 475 }
 476
 477 namespace {
 478 class TestEagerInitParallelExecutor : public folly::Executor {
 479  public:
 480   explicit TestEagerInitParallelExecutor(const size_t threadCount) {
 481     eventBases_.reserve(threadCount);
 482     threads_.reserve(threadCount);
 483     for (size_t i = 0; i < threadCount; i++) {
 484       eventBases_.push_back(std::make_shared<folly::EventBase>());
 485       auto eb = eventBases_.back();
 486       threads_.emplace_back(std::make_shared<std::thread>(
 487           [eb] { eb->loopForever(); }));
 488     }
 489   }
 490
 491   virtual ~TestEagerInitParallelExecutor() override {
 492     for (auto eb : eventBases_) {
 493       eb->runInEventBaseThread([eb] { eb->terminateLoopSoon(); });
 494     }
 495     for (auto thread : threads_) {
 496       thread->join();
 497     }
 498   }
 499
 500   virtual void add(folly::Func func) override {
 501     const auto index = (counter_ ++) % eventBases_.size();
 502     eventBases_[index]->add(std::move(func));
 503   }
 504
 505  private:
 506   std::vector<std::shared_ptr<folly::EventBase>> eventBases_;
 507   std::vector<std::shared_ptr<std::thread>> threads_;
 508   std::atomic<size_t> counter_ {0};
 509 };
 510 }  // namespace
 511
 512 namespace {
 513 struct EagerInitParallelTag {};
 514 }
 515 template <typename T, typename Tag = detail::DefaultTag>
 516 using SingletonEagerInitParallel = Singleton<T, Tag, EagerInitParallelTag>;
 517 TEST(Singleton, SingletonEagerInitParallel) {
 518   const static size_t kIters = 1000;
 519   const static size_t kThreads = 20;
 520
 521   std::atomic<size_t> initCounter;
 522
 523   auto& vault = *SingletonVault::singleton<EagerInitParallelTag>();
 524
 525   auto sing = SingletonEagerInitParallel<std::string>(
 526                   [&] {++initCounter; return new std::string(""); })
 527               .shouldEagerInit();
 528
 529   for (size_t i = 0; i < kIters; i++) {
 530     SCOPE_EXIT {
 531       // clean up each time
 532       vault.destroyInstances();
 533       vault.reenableInstances();
 534     };
 535
 536     initCounter.store(0);
 537
 538     {
 539       std::vector<std::shared_ptr<std::thread>> threads;
 540       boost::barrier barrier(kThreads);
 541       TestEagerInitParallelExecutor exe(kThreads);
 542       vault.registrationComplete();
 543
 544       EXPECT_EQ(0, initCounter.load());
 545
 546       for (size_t j = 0; j < kThreads; j++) {
 547         threads.push_back(std::make_shared<std::thread>([&] {
 548           barrier.wait();
 549           vault.doEagerInitVia(exe);
 550         }));
 551       }
 552
 553       for (auto thread : threads) {
 554         thread->join();
 555       }
 556     }
 557
 558     EXPECT_EQ(1, initCounter.load());
 559
 560     sing.get_weak();  // (avoid compile error complaining about unused var)
 561   }
 562 }
 563
 564 struct MockTag {};
 565 template <typename T, typename Tag = detail::DefaultTag>
 566 using SingletonMock = Singleton <T, Tag, MockTag>;
 567
 568 // Verify that existing Singleton's can be overridden
 569 // using the make_mock functionality.
 570 TEST(Singleton, MockTest) {
 571   auto& vault = *SingletonVault::singleton<MockTag>();
 572
 573   SingletonMock<Watchdog> watchdog_singleton;
 574   vault.registrationComplete();
 575
 576   // Registring singletons after registrationComplete called works
 577   // with make_mock (but not with Singleton ctor).
 578   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 579   int serial_count_first = SingletonMock<Watchdog>::try_get()->serial_number;
 580
 581   // Override existing mock using make_mock.
 582   SingletonMock<Watchdog>::make_mock();
 583
 584   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 585   int serial_count_mock = SingletonMock<Watchdog>::try_get()->serial_number;
 586
 587   // If serial_count value is the same, then singleton was not replaced.
 588   EXPECT_NE(serial_count_first, serial_count_mock);
 589
 590   // Override existing mock using make_mock one more time
 591   SingletonMock<Watchdog>::make_mock();
 592
 593   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 594   int serial_count_mock2 = SingletonMock<Watchdog>::try_get()->serial_number;
 595
 596   // If serial_count value is the same, then singleton was not replaced.
 597   EXPECT_NE(serial_count_first, serial_count_mock2);
 598   EXPECT_NE(serial_count_mock, serial_count_mock2);
 599
 600   vault.destroyInstances();
 601 }
 602
 603 #ifndef _MSC_VER
 604 // Subprocess isn't currently supported under MSVC.
 605 TEST(Singleton, DoubleRegistrationLogging) {
 606   const auto basename = "singleton_double_registration";
 607   const auto sub = fs::executable_path().remove_filename() / basename;
 608   auto p = Subprocess(
 609       std::vector<std::string>{sub.string()},
 610       Subprocess::Options()
 611           .stdinFd(Subprocess::CLOSE)
 612           .stdoutFd(Subprocess::CLOSE)
 613           .pipeStderr()
 614           .closeOtherFds());
 615   auto err = p.communicate("").second;
 616   auto res = p.wait();
 617   EXPECT_EQ(ProcessReturnCode::KILLED, res.state());
 618   EXPECT_EQ(SIGABRT, res.killSignal());
 619   EXPECT_THAT(err, testing::StartsWith("Double registration of singletons"));
 620 }
 621 #endif
 622
 623 // Singleton using a non default constructor test/example:
 624 struct X {
 625   X() : X(-1, "unset") {}
 626   X(int a1, std::string a2) : a1(a1), a2(a2) {
 627     LOG(INFO) << "X(" << a1 << "," << a2 << ")";
 628   }
 629   const int a1;
 630   const std::string a2;
 631 };
 632
 633 folly::Singleton<X> singleton_x([]() { return new X(42, "foo"); });
 634
 635 TEST(Singleton, CustomCreator) {
 636   X x1;
 637   std::shared_ptr<X> x2p = singleton_x.try_get();
 638   EXPECT_NE(nullptr, x2p);
 639   EXPECT_NE(x1.a1, x2p->a1);
 640   EXPECT_NE(x1.a2, x2p->a2);
 641   EXPECT_EQ(42, x2p->a1);
 642   EXPECT_EQ(std::string("foo"), x2p->a2);
 643 }
 644
 645 struct ConcurrentCreationDestructionTag {};
 646 template <typename T, typename Tag = detail::DefaultTag>
 647 using SingletonConcurrentCreationDestruction =
 648     Singleton<T, Tag, ConcurrentCreationDestructionTag>;
 649
 650 folly::Baton<> slowpokeNeedySingletonBaton;
 651
 652 struct SlowpokeNeedySingleton {
 653   SlowpokeNeedySingleton() {
 654     slowpokeNeedySingletonBaton.post();
 655     /* sleep override */ std::this_thread::sleep_for(
 656         std::chrono::milliseconds(100));
 657     auto unused =
 658         SingletonConcurrentCreationDestruction<NeededSingleton>::try_get();
 659     EXPECT_NE(unused, nullptr);
 660   }
 661 };
 662
 663 TEST(Singleton, ConcurrentCreationDestruction) {
 664   auto& vault = *SingletonVault::singleton<ConcurrentCreationDestructionTag>();
 665   SingletonConcurrentCreationDestruction<NeededSingleton> neededSingleton;
 666   SingletonConcurrentCreationDestruction<SlowpokeNeedySingleton> needySingleton;
 667   vault.registrationComplete();
 668
 669   std::thread needyThread([&] { needySingleton.try_get(); });
 670
 671   slowpokeNeedySingletonBaton.wait();
 672
 673   vault.destroyInstances();
 674
 675   needyThread.join();
 676 }
 677
 678 struct MainThreadDestructorTag {};
 679 template <typename T, typename Tag = detail::DefaultTag>
 680 using SingletonMainThreadDestructor =
 681     Singleton<T, Tag, MainThreadDestructorTag>;
 682
 683 struct ThreadLoggingSingleton {
 684   ThreadLoggingSingleton() {
 685     initThread = std::this_thread::get_id();
 686   }
 687
 688   ~ThreadLoggingSingleton() {
 689     destroyThread = std::this_thread::get_id();
 690   }
 691
 692   static std::thread::id initThread;
 693   static std::thread::id destroyThread;
 694 };
 695 std::thread::id ThreadLoggingSingleton::initThread{};
 696 std::thread::id ThreadLoggingSingleton::destroyThread{};
 697
 698 TEST(Singleton, MainThreadDestructor) {
 699   auto& vault = *SingletonVault::singleton<MainThreadDestructorTag>();
 700   SingletonMainThreadDestructor<ThreadLoggingSingleton> singleton;
 701
 702   vault.registrationComplete();
 703   EXPECT_EQ(std::thread::id(), ThreadLoggingSingleton::initThread);
 704
 705   singleton.try_get();
 706   EXPECT_EQ(std::this_thread::get_id(), ThreadLoggingSingleton::initThread);
 707
 708   std::thread t([instance = singleton.try_get()] {
 709     /* sleep override */ std::this_thread::sleep_for(
 710         std::chrono::milliseconds{100});
 711   });
 712
 713   EXPECT_EQ(std::thread::id(), ThreadLoggingSingleton::destroyThread);
 714
 715   vault.destroyInstances();
 716   EXPECT_EQ(std::this_thread::get_id(), ThreadLoggingSingleton::destroyThread);
 717
 718   t.join();
 719 }
 720
 721 TEST(Singleton, DoubleMakeMockAfterTryGet) {
 722   // to keep track of calls to ctor and dtor below
 723   struct Counts {
 724     size_t ctor = 0;
 725     size_t dtor = 0;
 726   };
 727
 728   // a test type which keeps track of its ctor and dtor calls
 729   struct VaultTag {};
 730   struct PrivateTag {};
 731   struct Object {
 732     explicit Object(Counts& counts) : counts_(counts) {
 733       ++counts_.ctor;
 734     }
 735     ~Object() {
 736       ++counts_.dtor;
 737     }
 738     Counts& counts_;
 739   };
 740   using SingletonObject = Singleton<Object, PrivateTag, VaultTag>;
 741
 742   // register everything
 743   Counts counts;
 744   auto& vault = *SingletonVault::singleton<VaultTag>();
 745   auto new_object = [&] { return new Object(counts); };
 746   SingletonObject object_(new_object);
 747   vault.registrationComplete();
 748
 749   // no eager inits, nada (sanity)
 750   EXPECT_EQ(0, counts.ctor);
 751   EXPECT_EQ(0, counts.dtor);
 752
 753   // explicit request, ctor
 754   SingletonObject::try_get();
 755   EXPECT_EQ(1, counts.ctor);
 756   EXPECT_EQ(0, counts.dtor);
 757
 758   // first make_mock, dtor (ctor is lazy)
 759   SingletonObject::make_mock(new_object);
 760   EXPECT_EQ(1, counts.ctor);
 761   EXPECT_EQ(1, counts.dtor);
 762
 763   // second make_mock, nada (dtor already ran, ctor is lazy)
 764   SingletonObject::make_mock(new_object);
 765   EXPECT_EQ(1, counts.ctor);
 766   EXPECT_EQ(1, counts.dtor);
 767 }