C++ AutoRequired::get方法代码示例

TEST_F(ContextCreatorTest, ValidateMultipleEviction) {
  AutoCurrentContext()->Initiate();

  // Number of dependent contexts to be created
  const size_t count = 100;

  // Teardown lock, counter, and condition:
  std::mutex lock;
  std::condition_variable cond;
  int counter = count;

  // Obtain creator pointer:
  AutoRequired<Creator> creator;

  // Set up a signal manager at global context scope:
  AutoRequired<GlobalSignal> signal;
  {
    // Array of objects to test destruction on, and corresponding collection of contexts:
    std::shared_ptr<WaitMember> members[count];

    // Create a few contexts:
    for(int i = count; i--;) {
      AutoCreateContext ctxt;
      CurrentContextPusher pshr(ctxt);

      // Trivial validation that the newly created context is an empty context:
      ASSERT_EQ(static_cast<size_t>(0), ctxt->GetMemberCount()) << "A created context was not empty";

      // Add in an object to test asynchronous destruction:
      AutoRequired<WaitMember> obj;
      members[i] = obj;
      ASSERT_EQ(signal.get(), obj->m_signal.get()) << "Dependent context wiring did not correctly match to the enclosing scope";

      // Add a notifier to signal a continue condition when we have everything we need:
      ctxt->AddTeardownListener([&lock, &cond, &counter] {
        (std::lock_guard<std::mutex>)lock,
        counter--,
        cond.notify_all();
      });

      // Kick off the context:
      ctxt->Initiate();
    }

    // Signal all members and then release everything:
    signal->Signal();
  }

  // Wait for all contexts to be destroyed
  std::unique_lock<std::mutex> lk(lock);
  bool wait_status = cond.wait_for(lk, std::chrono::seconds(1), [&counter] {return counter == 0;});
  ASSERT_TRUE(wait_status) << "All teardown listeners didn't trigger, counter still at " << counter;

  // Validate that everything expires:
  ASSERT_EQ(static_cast<size_t>(0), creator->GetSize()) << "Not all contexts were evicted as expected";
}

TEST_F(CoreContextTest, UnlinkOnTeardown) {
  std::weak_ptr<ClassThatPoints1> weakA;
  std::shared_ptr<ClassThatPoints2> strongB;
  AutoRequired<SimpleObject> so;

  // Set up a subcontext with some cycles and external links:
  {
    // Main context that gets reset second
    AutoCreateContext ctxt;

    // Sibling context that we're also going to reset
    AutoCreateContext otherContext;
    otherContext->Inject<std::vector<int>>();

    AutoRequired<ClassThatPoints1> a(ctxt);
    AutoRequired<ClassThatPoints2> b(ctxt, otherContext);
    weakA = a;
    strongB = b;

    ASSERT_TRUE(a->so.IsAutowired()) << "Root object pointer not correctly obtained";
    ASSERT_TRUE(b->so.IsAutowired()) << "Root object pointer not correctly obtained";

    ctxt->onTeardown +=
      [weakA, strongB] (const CoreContext&) {
        // Verify that nothing got screwed up at this point:
        auto a = weakA.lock();
        ASSERT_FALSE(weakA.expired()) << "Weak pointer expired prematurely";
        ASSERT_EQ(strongB, a->b) << "Unlink occurred prematurely";
        ASSERT_EQ(a, strongB->a) << "Unlink occured prematurely";
      };

    // Set the flag at the last possible and to ensure things still get torn down
    ctxt->SetUnlinkOnTeardown(true);
  }

  ASSERT_TRUE(weakA.expired()) << "A reference was leaked even though unlinking was turned on";
  ASSERT_TRUE(strongB->v.IsAutowired()) << "An Autowired field pointing to a foreign context was incorrectly unlinked";
  ASSERT_EQ(so.get(), strongB->so.get()) << "An Autowired field was unlinked on teardown even though it pointed outside of a context";
}