2 * Copyright 2016 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
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>
27 #include <folly/Subprocess.h>
30 #include <glog/logging.h>
31 #include <boost/thread/barrier.hpp>
33 FOLLY_GCC_DISABLE_WARNING(deprecated-declarations)
35 using namespace folly;
37 TEST(Singleton, MissingSingleton) {
38 EXPECT_DEATH([]() { auto u = Singleton<UnregisteredWatchdog>::try_get(); }(),
42 struct BasicUsageTag {};
43 template <typename T, typename Tag = detail::DefaultTag>
44 using SingletonBasicUsage = Singleton <T, Tag, BasicUsageTag>;
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>();
52 EXPECT_EQ(vault.registeredSingletonCount(), 0);
53 SingletonBasicUsage<Watchdog> watchdog_singleton;
54 EXPECT_EQ(vault.registeredSingletonCount(), 1);
56 SingletonBasicUsage<ChildWatchdog> child_watchdog_singleton;
57 EXPECT_EQ(vault.registeredSingletonCount(), 2);
59 vault.registrationComplete();
61 // limit a scope to release references so we can destroy them later
63 std::shared_ptr<Watchdog> s1 = SingletonBasicUsage<Watchdog>::try_get();
64 EXPECT_NE(s1, nullptr);
66 std::shared_ptr<Watchdog> s2 = SingletonBasicUsage<Watchdog>::try_get();
67 EXPECT_NE(s2, nullptr);
70 EXPECT_EQ(s1.get(), SingletonBasicUsage<Watchdog>::try_get_fast().get());
72 std::shared_ptr<ChildWatchdog> s3 =
73 SingletonBasicUsage<ChildWatchdog>::try_get();
74 EXPECT_NE(s3, nullptr);
77 EXPECT_EQ(vault.registeredSingletonCount(), 2);
78 EXPECT_EQ(vault.livingSingletonCount(), 2);
81 vault.destroyInstances();
82 EXPECT_EQ(vault.registeredSingletonCount(), 2);
83 EXPECT_EQ(vault.livingSingletonCount(), 0);
86 struct DirectUsageTag {};
87 template <typename T, typename Tag = detail::DefaultTag>
88 using SingletonDirectUsage = Singleton <T, Tag, DirectUsageTag>;
90 TEST(Singleton, DirectUsage) {
91 auto& vault = *SingletonVault::singleton<DirectUsageTag>();
93 EXPECT_EQ(vault.registeredSingletonCount(), 0);
95 // Verify we can get to the underlying singletons via directly using
96 // the singleton definition.
97 SingletonDirectUsage<Watchdog> watchdog;
99 SingletonDirectUsage<Watchdog, TestTag> named_watchdog;
100 EXPECT_EQ(vault.registeredSingletonCount(), 2);
101 vault.registrationComplete();
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);
108 vault.destroyInstances();
111 struct NamedUsageTag {};
112 template <typename T, typename Tag = detail::DefaultTag>
113 using SingletonNamedUsage = Singleton <T, Tag, NamedUsageTag>;
115 TEST(Singleton, NamedUsage) {
116 auto& vault = *SingletonVault::singleton<NamedUsageTag>();
118 EXPECT_EQ(vault.registeredSingletonCount(), 0);
120 // Define two named Watchdog singletons and one unnamed singleton.
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);
131 vault.registrationComplete();
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());
139 auto s3 = SingletonNamedUsage<Watchdog, Watchdog3>::try_get();
140 EXPECT_EQ(s3, watchdog3_singleton.try_get());
144 // Verify the "default" singleton is the same as the DefaultTag-tagged
146 auto s4 = SingletonNamedUsage<Watchdog>::try_get();
147 EXPECT_EQ(s4, watchdog3_singleton.try_get());
150 vault.destroyInstances();
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>;
160 // Some pathological cases such as getting unregistered singletons,
161 // double registration, etc.
162 TEST(Singleton, NaughtyUsage) {
163 auto& vault = *SingletonVault::singleton<NaughtyUsageTag>();
165 vault.registrationComplete();
168 EXPECT_DEATH(Singleton<Watchdog>::try_get(), "");
169 EXPECT_DEATH(SingletonNaughtyUsage<Watchdog>::try_get(), "");
171 vault.destroyInstances();
173 auto& vault2 = *SingletonVault::singleton<NaughtyUsageTag2>();
175 EXPECT_DEATH(SingletonNaughtyUsage2<Watchdog>::try_get(), "");
176 SingletonNaughtyUsage2<Watchdog> watchdog_singleton;
178 // double registration
179 EXPECT_DEATH([]() { SingletonNaughtyUsage2<Watchdog> w2; }(), "");
180 vault2.destroyInstances();
182 // double registration after destroy
183 EXPECT_DEATH([]() { SingletonNaughtyUsage2<Watchdog> w3; }(), "");
186 struct SharedPtrUsageTag {};
187 template <typename T, typename Tag = detail::DefaultTag>
188 using SingletonSharedPtrUsage = Singleton <T, Tag, SharedPtrUsageTag>;
190 // TODO (anob): revisit this test
191 TEST(Singleton, SharedPtrUsage) {
192 struct WatchdogHolder {
195 LOG(ERROR) << "The following log message with stack trace is expected";
199 std::shared_ptr<Watchdog> watchdog;
202 auto& vault = *SingletonVault::singleton<SharedPtrUsageTag>();
204 EXPECT_EQ(vault.registeredSingletonCount(), 0);
205 SingletonSharedPtrUsage<Watchdog> watchdog_singleton;
206 EXPECT_EQ(vault.registeredSingletonCount(), 1);
208 SingletonSharedPtrUsage<ChildWatchdog> child_watchdog_singleton;
209 EXPECT_EQ(vault.registeredSingletonCount(), 2);
212 SingletonSharedPtrUsage<Watchdog, ATag> named_watchdog_singleton;
214 SingletonSharedPtrUsage<WatchdogHolder> watchdog_holder_singleton;
216 vault.registrationComplete();
218 // Initilize holder singleton first, so that it's the last one to be
220 watchdog_holder_singleton.try_get();
222 auto s1 = SingletonSharedPtrUsage<Watchdog>::try_get().get();
223 EXPECT_NE(s1, nullptr);
225 auto s2 = SingletonSharedPtrUsage<Watchdog>::try_get().get();
226 EXPECT_NE(s2, nullptr);
230 auto weak_s1 = SingletonSharedPtrUsage<Watchdog>::get_weak();
232 auto shared_s1 = weak_s1.lock();
233 EXPECT_EQ(shared_s1.get(), s1);
234 EXPECT_EQ(shared_s1.use_count(), 2);
236 auto old_serial = shared_s1->serial_number;
240 SingletonSharedPtrUsage<Watchdog, ATag>::get_weak();
241 auto locked = named_weak_s1.lock();
242 EXPECT_NE(locked.get(), shared_s1.get());
245 // We should release externally locked shared_ptr, otherwise it will be
247 watchdog_holder_singleton.try_get()->watchdog = std::move(shared_s1);
249 LOG(ERROR) << "The following log message regarding shared_ptr is expected";
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});
257 EXPECT_EQ(vault.registeredSingletonCount(), 4);
258 EXPECT_EQ(vault.livingSingletonCount(), 0);
260 EXPECT_TRUE(weak_s1.expired());
262 auto empty_s1 = SingletonSharedPtrUsage<Watchdog>::get_weak();
263 EXPECT_FALSE(empty_s1.lock());
265 vault.reenableInstances();
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);
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();
281 new_s1_shared.reset();
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});
289 EXPECT_TRUE(new_s1_weak.expired());
293 // Some classes to test singleton dependencies. NeedySingleton has a
294 // dependency on NeededSingleton, which happens during its
297 template <typename T, typename Tag = detail::DefaultTag>
298 using SingletonNeedy = Singleton <T, Tag, NeedyTag>;
300 struct NeededSingleton {};
301 struct NeedySingleton {
303 auto unused = SingletonNeedy<NeededSingleton>::try_get();
304 EXPECT_NE(unused, nullptr);
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>;
313 struct SelfNeedySingleton {
314 SelfNeedySingleton() {
315 auto unused = SingletonSelfNeedy<SelfNeedySingleton>::try_get();
316 EXPECT_NE(unused, nullptr);
320 TEST(Singleton, SingletonDependencies) {
321 SingletonNeedy<NeededSingleton> needed_singleton;
322 SingletonNeedy<NeedySingleton> needy_singleton;
323 auto& needy_vault = *SingletonVault::singleton<NeedyTag>();
325 needy_vault.registrationComplete();
327 EXPECT_EQ(needy_vault.registeredSingletonCount(), 2);
328 EXPECT_EQ(needy_vault.livingSingletonCount(), 0);
330 auto needy = SingletonNeedy<NeedySingleton>::try_get();
331 EXPECT_EQ(needy_vault.livingSingletonCount(), 2);
333 SingletonSelfNeedy<SelfNeedySingleton> self_needy_singleton;
334 auto& self_needy_vault = *SingletonVault::singleton<SelfNeedyTag>();
336 self_needy_vault.registrationComplete();
337 EXPECT_DEATH([]() { SingletonSelfNeedy<SelfNeedySingleton>::try_get(); }(),
341 // A test to ensure multiple threads contending on singleton creation
342 // properly wait for creation rather than thinking it is a circular
344 class Slowpoke : public Watchdog {
346 Slowpoke() { std::this_thread::sleep_for(std::chrono::milliseconds(10)); }
349 struct ConcurrencyTag {};
350 template <typename T, typename Tag = detail::DefaultTag>
351 using SingletonConcurrency = Singleton <T, Tag, ConcurrencyTag>;
353 TEST(Singleton, SingletonConcurrency) {
354 auto& vault = *SingletonVault::singleton<ConcurrencyTag>();
355 SingletonConcurrency<Slowpoke> slowpoke_singleton;
356 vault.registrationComplete();
358 std::mutex gatekeeper;
360 auto func = [&gatekeeper]() {
363 auto unused = SingletonConcurrency<Slowpoke>::try_get();
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);
371 // If circular dependency checks fail, the unlock would trigger a
372 // crash. Instead, it succeeds, and we have exactly one living
375 for (auto& t : threads) {
378 EXPECT_EQ(vault.livingSingletonCount(), 1);
381 struct ErrorConstructor {
382 static size_t constructCount_;
384 if ((constructCount_++) == 0) {
385 throw std::runtime_error("first time fails");
389 size_t ErrorConstructor::constructCount_(0);
391 struct CreationErrorTag {};
392 template <typename T, typename Tag = detail::DefaultTag>
393 using SingletonCreationError = Singleton<T, Tag, CreationErrorTag>;
395 TEST(Singleton, SingletonCreationError) {
396 SingletonCreationError<ErrorConstructor> error_once_singleton;
397 SingletonVault::singleton<CreationErrorTag>()->registrationComplete();
399 // first time should error out
400 EXPECT_THROW(error_once_singleton.try_get(), std::runtime_error);
402 // second time it'll work fine
403 error_once_singleton.try_get();
407 struct ConcurrencyStressTag {};
408 template <typename T, typename Tag = detail::DefaultTag>
409 using SingletonConcurrencyStress = Singleton <T, Tag, ConcurrencyStressTag>;
411 TEST(Singleton, SingletonConcurrencyStress) {
412 auto& vault = *SingletonVault::singleton<ConcurrencyStressTag>();
413 SingletonConcurrencyStress<Slowpoke> slowpoke_singleton;
414 vault.registrationComplete();
416 std::vector<std::thread> ts;
417 for (size_t i = 0; i < 100; ++i) {
418 ts.emplace_back([&]() {
419 slowpoke_singleton.try_get();
423 for (size_t i = 0; i < 100; ++i) {
424 std::chrono::milliseconds d(20);
426 std::this_thread::sleep_for(d);
427 vault.destroyInstances();
428 std::this_thread::sleep_for(d);
429 vault.destroyInstances();
438 struct EagerInitSyncTag {};
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"); })
448 vault.registrationComplete();
449 EXPECT_FALSE(didEagerInit);
451 EXPECT_TRUE(didEagerInit);
452 sing.get_weak(); // (avoid compile error complaining about unused var 'sing')
456 struct EagerInitAsyncTag {};
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"); })
468 vault.registrationComplete();
469 EXPECT_FALSE(didEagerInit);
470 vault.doEagerInitVia(eb, &done);
473 EXPECT_TRUE(didEagerInit);
474 sing.get_weak(); // (avoid compile error complaining about unused var 'sing')
478 class TestEagerInitParallelExecutor : public folly::Executor {
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(); }));
491 virtual ~TestEagerInitParallelExecutor() override {
492 for (auto eb : eventBases_) {
493 eb->runInEventBaseThread([eb] { eb->terminateLoopSoon(); });
495 for (auto thread : threads_) {
500 virtual void add(folly::Func func) override {
501 const auto index = (counter_ ++) % eventBases_.size();
502 eventBases_[index]->add(std::move(func));
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};
513 struct EagerInitParallelTag {};
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;
521 std::atomic<size_t> initCounter;
523 auto& vault = *SingletonVault::singleton<EagerInitParallelTag>();
525 auto sing = SingletonEagerInitParallel<std::string>(
526 [&] {++initCounter; return new std::string(""); })
529 for (size_t i = 0; i < kIters; i++) {
531 // clean up each time
532 vault.destroyInstances();
533 vault.reenableInstances();
536 initCounter.store(0);
539 std::vector<std::shared_ptr<std::thread>> threads;
540 boost::barrier barrier(kThreads);
541 TestEagerInitParallelExecutor exe(kThreads);
542 vault.registrationComplete();
544 EXPECT_EQ(0, initCounter.load());
546 for (size_t j = 0; j < kThreads; j++) {
547 threads.push_back(std::make_shared<std::thread>([&] {
549 vault.doEagerInitVia(exe);
553 for (auto thread : threads) {
558 EXPECT_EQ(1, initCounter.load());
560 sing.get_weak(); // (avoid compile error complaining about unused var)
565 template <typename T, typename Tag = detail::DefaultTag>
566 using SingletonMock = Singleton <T, Tag, MockTag>;
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>();
573 SingletonMock<Watchdog> watchdog_singleton;
574 vault.registrationComplete();
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;
581 // Override existing mock using make_mock.
582 SingletonMock<Watchdog>::make_mock();
584 EXPECT_EQ(vault.registeredSingletonCount(), 1);
585 int serial_count_mock = SingletonMock<Watchdog>::try_get()->serial_number;
587 // If serial_count value is the same, then singleton was not replaced.
588 EXPECT_NE(serial_count_first, serial_count_mock);
590 // Override existing mock using make_mock one more time
591 SingletonMock<Watchdog>::make_mock();
593 EXPECT_EQ(vault.registeredSingletonCount(), 1);
594 int serial_count_mock2 = SingletonMock<Watchdog>::try_get()->serial_number;
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);
600 vault.destroyInstances();
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;
609 std::vector<std::string>{sub.string()},
610 Subprocess::Options()
611 .stdinFd(Subprocess::CLOSE)
612 .stdoutFd(Subprocess::CLOSE)
615 auto err = p.communicate("").second;
617 EXPECT_EQ(ProcessReturnCode::KILLED, res.state());
618 EXPECT_EQ(SIGABRT, res.killSignal());
619 EXPECT_THAT(err, testing::StartsWith("Double registration of singletons"));
623 // Singleton using a non default constructor test/example:
625 X() : X(-1, "unset") {}
626 X(int a1, std::string a2) : a1(a1), a2(a2) {
627 LOG(INFO) << "X(" << a1 << "," << a2 << ")";
630 const std::string a2;
633 folly::Singleton<X> singleton_x([]() { return new X(42, "foo"); });
635 TEST(Singleton, CustomCreator) {
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);