void scheduleEvents(EventBase* eventBase, int fd, ScheduledEvent* events) {
for (ScheduledEvent* ev = events; ev->milliseconds > 0; ++ev) {
- eventBase->runAfterDelay(std::bind(&ScheduledEvent::perform, ev, fd),
+ eventBase->tryRunAfterDelay(std::bind(&ScheduledEvent::perform, ev, fd),
ev->milliseconds);
}
}
scheduleEvents(&eb, sp[1], events);
// Schedule a timeout to unregister the handler after the third write
- eb.runAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 85);
+ eb.tryRunAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 85);
// Loop
TimePoint start;
scheduleEvents(&eb, sp[1], events);
// Schedule a timeout to unregister the handler
- eb.runAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 20);
+ eb.tryRunAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 20);
// Loop
TimePoint start;
scheduleEvents(&eb, sp[1], events);
// Schedule a timeout to unregister the handler after the third read
- eb.runAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 85);
+ eb.tryRunAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 85);
// Loop
TimePoint start;
// Schedule a timeout to unregister the handler
int64_t unregisterTimeout = 40;
- eb.runAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler),
+ eb.tryRunAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler),
unregisterTimeout);
// Loop
scheduleEvents(&eb, sp[1], events);
// Schedule a timeout to unregister the handler
- eb.runAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 80);
+ eb.tryRunAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 80);
// Loop
TimePoint start;
scheduleEvents(&eb, sp[1], events);
// Schedule a timeout to unregister the handler
- eb.runAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 30);
+ eb.tryRunAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 30);
// Loop
TimePoint start;
scheduleEvents(&eb, sp[1], events);
// Schedule a timeout to unregister the handler
- eb.runAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 30);
+ eb.tryRunAfterDelay(std::bind(&TestHandler::unregisterHandler, &handler), 30);
// Loop
TimePoint start;
// After 10ms, read some data, so that the handler
// will be notified that it can write.
- eb.runAfterDelay(std::bind(checkReadUntilEmpty, sp[1], initialBytesWritten),
+ eb.tryRunAfterDelay(std::bind(checkReadUntilEmpty, sp[1], initialBytesWritten),
10);
// Start a timer to destroy the handler after 25ms
TimePoint timestamp1(false);
TimePoint timestamp2(false);
TimePoint timestamp3(false);
- eb.runAfterDelay(std::bind(&TimePoint::reset, ×tamp1), 10);
- eb.runAfterDelay(std::bind(&TimePoint::reset, ×tamp2), 20);
- eb.runAfterDelay(std::bind(&TimePoint::reset, ×tamp3), 40);
+ eb.tryRunAfterDelay(std::bind(&TimePoint::reset, ×tamp1), 10);
+ eb.tryRunAfterDelay(std::bind(&TimePoint::reset, ×tamp2), 20);
+ eb.tryRunAfterDelay(std::bind(&TimePoint::reset, ×tamp3), 40);
TimePoint start;
eb.loop();
}
/**
- * Test the behavior of runAfterDelay() when some timeouts are
+ * Test the behavior of tryRunAfterDelay() when some timeouts are
* still scheduled when the EventBase is destroyed.
*/
TEST(EventBaseTest, RunAfterDelayDestruction) {
EventBase eb;
// Run two normal timeouts
- eb.runAfterDelay(std::bind(&TimePoint::reset, ×tamp1), 10);
- eb.runAfterDelay(std::bind(&TimePoint::reset, ×tamp2), 20);
+ eb.tryRunAfterDelay(std::bind(&TimePoint::reset, ×tamp1), 10);
+ eb.tryRunAfterDelay(std::bind(&TimePoint::reset, ×tamp2), 20);
// Schedule a timeout to stop the event loop after 40ms
- eb.runAfterDelay(std::bind(&EventBase::terminateLoopSoon, &eb), 40);
+ eb.tryRunAfterDelay(std::bind(&EventBase::terminateLoopSoon, &eb), 40);
// Schedule 2 timeouts that would fire after the event loop stops
- eb.runAfterDelay(std::bind(&TimePoint::reset, ×tamp3), 80);
- eb.runAfterDelay(std::bind(&TimePoint::reset, ×tamp4), 160);
+ eb.tryRunAfterDelay(std::bind(&TimePoint::reset, ×tamp3), 80);
+ eb.tryRunAfterDelay(std::bind(&TimePoint::reset, ×tamp4), 160);
start.reset();
eb.loop();
&AsyncTimeout::scheduleTimeout);
// after 10ms, reschedule t2 to run sooner than originally scheduled
- eb.runAfterDelay(std::bind(f, &t2, 10), 10);
+ eb.tryRunAfterDelay(std::bind(f, &t2, 10), 10);
// after 10ms, reschedule t3 to run later than originally scheduled
- eb.runAfterDelay(std::bind(f, &t3, 40), 10);
+ eb.tryRunAfterDelay(std::bind(f, &t3, 40), 10);
TimePoint start;
eb.loop();
ReschedulingTimeout t(&eb, timeouts);
t.start();
- eb.runAfterDelay(std::bind(&AsyncTimeout::cancelTimeout, &t), 50);
+ eb.tryRunAfterDelay(std::bind(&AsyncTimeout::cancelTimeout, &t), 50);
TimePoint start;
eb.loop();
// Once the last thread exits, it will stop the loop(). However, this
// timeout also stops the loop in case there is a bug performing the normal
// stop.
- data.evb.runAfterDelay(std::bind(&EventBase::terminateLoopSoon, &data.evb),
+ data.evb.tryRunAfterDelay(std::bind(&EventBase::terminateLoopSoon, &data.evb),
3000);
TimePoint start;
TEST(EventBaseTest, RunBeforeLoopWait) {
EventBase base;
CountedLoopCallback cb(&base, 1);
- base.runAfterDelay([&](){
+ base.tryRunAfterDelay([&](){
base.terminateLoopSoon();
}, 500);
base.runBeforeLoop(&cb);