C++ Baton::timed_wait方法代码示例

void run_timed_wait_regular_test() {
  Baton<Atom> b;

  auto thr = DSched::thread([&] {
    // To wait forever we'd like to use time_point<Clock>::max, but
    // std::condition_variable does math to convert the timeout to
    // system_clock without handling overflow.
    auto farFuture = Clock::now() + std::chrono::hours(1000);
    bool rv = b.timed_wait(farFuture);
    if (!std::is_same<Atom<int>, DeterministicAtomic<int>>::value) {
      // DeterministicAtomic ignores actual times, so doesn't guarantee
      // a lack of timeout
      EXPECT_TRUE(rv);
    }
  });

  if (!std::is_same<Atom<int>, DeterministicAtomic<int>>::value) {
    // If we are using std::atomic (or EmulatedFutexAtomic) then
    // a sleep here guarantees to a large extent that 'thr' will
    // execute wait before we post it, thus testing late delivery. For
    // DeterministicAtomic, we just rely on DeterministicSchedule to do
    // the scheduling.  The test won't fail if we lose the race, we just
    // don't get coverage.
    std::this_thread::sleep_for(std::chrono::milliseconds(2));
  }

  b.post();
  DSched::join(thr);
}

TEST_F(EventBaseThreadTest, example) {
  EventBaseThread ebt;

  Baton<> done;
  ebt.getEventBase()->runInEventBaseThread([&] { done.post(); });
  ASSERT_TRUE(done.timed_wait(seconds(1)));
}

TEST(Interrupt, withinTimedOut) {
  Promise<int> p;
  Baton<> done;
  p.setInterruptHandler([&](const exception_wrapper& /* e */) { done.post(); });
  p.getFuture().within(std::chrono::milliseconds(1));
  // Give it 100ms to time out and call the interrupt handler
  auto t = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
  EXPECT_TRUE(done.timed_wait(t));
}

void run_timed_wait_tmo_tests() {
  Baton<Atom> b;

  auto thr = DSched::thread([&]{
    bool rv = b.timed_wait(Clock::now() + std::chrono::milliseconds(1));
    // main thread is guaranteed to not post until timeout occurs
    EXPECT_FALSE(rv);
  });
  DSched::join(thr);
}

TEST_F(FilePollerTest, TestUpdateFileBackwards) {
  createFile();
  Baton<> baton;
  bool updated = false;
  FilePoller poller(tmpFile, std::chrono::milliseconds(1));
  poller.addCallback([&]() {
    updated = true;
    baton.post();
  });
  updateModifiedTime(tmpFile, false);
  ASSERT_TRUE(baton.timed_wait(std::chrono::seconds(5)));
  ASSERT_TRUE(updated);
}

TEST_F(ProcessTicketTest, TestUpdateTicketFile) {
  Baton<> baton;
  TLSTicketProcessor processor(ticketFile);
  bool updated = false;
  processor.addCallback([&](TLSTicketKeySeeds) {
    updated = true;
    baton.post();
  });
  CHECK(writeFile(validTicketData, ticketFile.c_str()));
  updateModifiedTime(ticketFile);
  baton.timed_wait(std::chrono::seconds(30));
  ASSERT_TRUE(updated);
}

TEST_F(EventBaseThreadTest, move) {
  auto ebt0 = EventBaseThread();
  auto ebt1 = std::move(ebt0);
  auto ebt2 = std::move(ebt1);

  EXPECT_EQ(nullptr, ebt0.getEventBase());
  EXPECT_EQ(nullptr, ebt1.getEventBase());
  EXPECT_NE(nullptr, ebt2.getEventBase());

  Baton<> done;
  ebt2.getEventBase()->runInEventBaseThread([&] { done.post(); });
  ASSERT_TRUE(done.timed_wait(seconds(1)));
}

TEST_F(EventBaseThreadTest, start_stop) {
  EventBaseThread ebt(false);

  for (size_t i = 0; i < 4; ++i) {
    EXPECT_EQ(nullptr, ebt.getEventBase());
    ebt.start();
    EXPECT_NE(nullptr, ebt.getEventBase());

    Baton<> done;
    ebt.getEventBase()->runInEventBaseThread([&] { done.post(); });
    ASSERT_TRUE(done.timed_wait(seconds(1)));

    EXPECT_NE(nullptr, ebt.getEventBase());
    ebt.stop();
    EXPECT_EQ(nullptr, ebt.getEventBase());
  }
}

void run_timed_wait_regular_test() {
  Baton<Atom> b;

  auto thr = DSched::thread([&] {
    bool rv = b.timed_wait(
                std::chrono::time_point<std::chrono::system_clock>::max());
    if (std::is_same<Atom<int>, std::atomic<int>>::value) {
      // We can only ensure this for std::atomic
      EXPECT_TRUE(rv);
    }
  });

  if (std::is_same<Atom<int>, std::atomic<int>>::value) {
    // If we are using std::atomic, then a sleep here guarantees to a large
    // extent that 'thr' will execute wait before we post it, thus testing
    // late delivery. For DeterministicAtomic, we just rely on
    // DeterministicSchedule to do the scheduling
    std::this_thread::sleep_for(std::chrono::milliseconds(2));
  }

  b.post();
  DSched::join(thr);
}

void run_basic_timed_wait_tests() {
  Baton<Atom> b;
  b.post();
  // tests if early delivery works fine
  EXPECT_TRUE(b.timed_wait(std::chrono::system_clock::now()));
}