develop #comment Unit tests for scheduling periodic tasks.

 - Use one future in the test fixtures to synchronize the managers/schedulers.

Author: Luc Sinet

test/ManagerTest.hh

@@ -26,21 +26,17 @@ class ManagerTest : public Test {
   };
 
   void setup(size_t poolWorkersCount, size_t managerWorkersCount) {
-    for (size_t i = 0; i < poolWorkersCount; ++i) {
-      _locks.emplace_back();
-    }
-    std::vector<std::shared_future<void>> futures(_locks.size());
-
-    for (size_t i = 0; i < _locks.size(); ++i) {
-      futures[i] = _locks[i].get_future();
+    if (!_lock.first) {
+      _lock.first = std::make_unique<std::promise<void>>();
+      _lock.second = _lock.first->get_future();
     }
 
     _threadpool = std::make_shared<Detail::Threadpool>(poolWorkersCount);
     _manager = std::make_shared<Manager>(_threadpool, managerWorkersCount);
 
-    for (size_t i = 0; i < futures.size(); ++i) {
-      auto task = [future = std::move(futures[i])] {
-        EXPECT_EQ(std::future_status::ready, future.wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
+    for (size_t i = 0; i < managerWorkersCount; ++i) {
+      auto task = [this] {
+        EXPECT_EQ(std::future_status::ready, _lock.second.wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
       };
       _manager->launch(std::move(task));
     }
@@ -52,8 +48,8 @@ class ManagerTest : public Test {
     }
   }
   void runTasks() {
-    for (auto& lock : _locks) {
-      lock.set_value();
+    if (_lock.first) {
+      _lock.first->set_value();
     }
     for (auto& future : _futures) {
       EXPECT_EQ(std::future_status::ready, future.wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
@@ -64,7 +60,7 @@ class ManagerTest : public Test {
  protected:
   std::shared_ptr<Detail::Threadpool> _threadpool;
   std::shared_ptr<Manager> _manager;
-  std::vector<std::promise<void>> _locks;
+  std::pair<std::unique_ptr<std::promise<void>>, std::shared_future<void>> _lock;
   std::vector<std::shared_future<void>> _futures;
 };
 

test/SchedulerTest.cpp

@@ -110,6 +110,56 @@ TEST_F(SchedulerTest, scheduleNested) {
   this->runTasks();
 }
 
+TEST_F(SchedulerTest, schedulePeriodic) {
+  auto threadpool = std::make_shared<Detail::Threadpool>(2);
+  auto scheduler = std::make_shared<Scheduler>(threadpool, 1);
+  std::promise<void> p;
+  auto f = p.get_future();
+  size_t i = 0;
+
+  scheduler->scheduleEvery("0", std::chrono::milliseconds(0), [&i, &p] {
+    ++i;
+    if (i == 5) {
+      p.set_value();
+    }
+  });
+
+  EXPECT_EQ(std::future_status::ready, f.wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
+  EXPECT_EQ(std::future_status::ready, scheduler->stop().wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
+}
+
+TEST_F(SchedulerTest, multiplePeriodicTasksOneWorker) {
+  _threadpool = std::make_shared<Detail::Threadpool>(2);
+  auto scheduler = this->setupScheduler(1);
+  std::promise<void> p;
+  auto f = p.get_future();
+  std::string strA = "HloWrd";
+  std::string strB = "el ol!";
+  std::string expected = "Hello World!";
+  std::string final;
+  size_t i = 0;
+
+  scheduler->scheduleEvery("A", std::chrono::milliseconds(0), [&] { //
+    if (i < strA.size()) {
+      final.push_back(strA[i]);
+    }
+  });
+  scheduler->scheduleEvery("B", std::chrono::milliseconds(0), [&] { //
+    if (i < strB.size()) {
+      final.push_back(strB[i++]);
+      if (i == strB.size()) {
+        p.set_value();
+      }
+    }
+  });
+  // Unblock the scheduler.
+  this->runTasks();
+  EXPECT_EQ(std::future_status::ready, f.wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
+
+  EXPECT_EQ(expected, final);
+  EXPECT_EQ(std::future_status::ready, scheduler->stop().wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
+}
+
 TEST_F(SchedulerTest, erase) {
   size_t n = 0;
 
@@ -156,7 +206,7 @@ TEST_F(SchedulerTest, scheduleOnStopped) {
   auto threadpool = std::make_shared<Detail::Threadpool>(2);
   auto scheduler = std::make_shared<Scheduler>(threadpool, 1);
 
-  scheduler->stop().get();
+  EXPECT_EQ(std::future_status::ready, scheduler->stop().wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
   auto future = scheduler->scheduleIn("0", std::chrono::milliseconds(0), [] {});
 
   EXPECT_FALSE(scheduler->isScheduled("0"));

test/SchedulerTest.hh

@@ -27,24 +27,25 @@ class SchedulerTest : public Test {
   };
 
   void setup(size_t poolWorkersCount, size_t schedulerWorkersCount) {
-    for (size_t i = 0; i < poolWorkersCount; ++i) {
-      _locks.emplace_back();
-    }
-    std::vector<std::shared_future<void>> futures(_locks.size());
+    _threadpool = std::make_shared<Detail::Threadpool>(poolWorkersCount);
+    _scheduler = this->setupScheduler(schedulerWorkersCount);
+  }
 
-    for (size_t i = 0; i < _locks.size(); ++i) {
-      futures[i] = _locks[i].get_future();
+  std::shared_ptr<Scheduler> setupScheduler(size_t schedulerWorkersCount) {
+    if (!_lock.first) {
+      _lock.first = std::make_unique<std::promise<void>>();
+      _lock.second = _lock.first->get_future();
     }
 
-    _threadpool = std::make_shared<Detail::Threadpool>(poolWorkersCount);
-    _scheduler = std::make_shared<Scheduler>(_threadpool, schedulerWorkersCount);
-
-    for (size_t i = 0; i < futures.size(); ++i) {
-      auto task = [future = std::move(futures[i])] {
-        EXPECT_EQ(std::future_status::ready, future.wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
+    auto scheduler = std::make_shared<Scheduler>(_threadpool, schedulerWorkersCount);
+    for (size_t i = 0; i < schedulerWorkersCount; ++i) {
+      auto task = [this] {
+        EXPECT_EQ(std::future_status::ready, _lock.second.wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
       };
-      _scheduler->scheduleIn("setup_" + std::to_string(i), -std::chrono::hours(1), std::move(task));
+      scheduler->scheduleIn("setup_" + std::to_string(i), -std::chrono::hours(1), std::move(task));
     }
+
+    return scheduler;
   }
 
   void addTasks(std::vector<std::pair<std::function<void()>, std::chrono::microseconds>>&& functors) {
@@ -54,8 +55,8 @@ class SchedulerTest : public Test {
     }
   }
   void runTasks() {
-    for (auto& lock : _locks) {
-      lock.set_value();
+    if (_lock.first) {
+      _lock.first->set_value();
     }
     for (auto& future : _futures) {
       EXPECT_EQ(std::future_status::ready, future.wait_for(std::chrono::milliseconds(Async::kTestTimeout)));
@@ -66,7 +67,7 @@ class SchedulerTest : public Test {
  protected:
   std::shared_ptr<Detail::Threadpool> _threadpool;
   std::shared_ptr<Scheduler> _scheduler;
-  std::vector<std::promise<void>> _locks;
+  std::pair<std::unique_ptr<std::promise<void>>, std::shared_future<void>> _lock;
   std::vector<std::shared_future<void>> _futures;
 };