Force threadpool_scheduler of size 1 to use just a single thread (for data confinement) about asyncplusplus HOT 1 CLOSED

#include <gtest/gtest.h>
#include <chrono>
#include <ranges>
#include <algorithm>
#include <thread>
#include <vector>
#include <set>
#include <async++.h>

TEST(Task, ThreadpoolSchedulerOfSize1IsSingleThreadWithWorkQueue) {
  using namespace std::chrono_literals;

  async::threadpool_scheduler scheduler{1};

  std::set<std::thread::id> threadIds;
  std::vector<std::chrono::high_resolution_clock::time_point> startTimes;
  constexpr auto INTERVAL = 2s;

  auto task = [&] {
    startTimes.push_back(std::chrono::high_resolution_clock::now());
    threadIds.insert(std::this_thread::get_id());
    std::this_thread::sleep_for(INTERVAL);
  };

  auto firstTask = async::spawn(scheduler, task)
                       .then(scheduler, task)
                       .then(scheduler, task)
                       .then(scheduler, task);

  // I expect these to be executed after or in-between sub-tasks of the first
  // task
  auto secondTask = async::spawn(scheduler, task);
  auto thirdTask = async::spawn(scheduler, task);

  std::vector<async::task<void>> tasks{};
  tasks.push_back(std::move(firstTask));
  tasks.push_back(std::move(secondTask));
  tasks.push_back(std::move(thirdTask));

  async::when_all(tasks.begin(), tasks.end()).wait();

  // This fails
  EXPECT_EQ(1u, threadIds.size());

  // Each task should have been executed around INTERVAL after the last one.
  std::vector<std::chrono::duration<double>> startTimesDifferences;
  std::ranges::transform(startTimes | std::views::drop(1), startTimes,
                         std::back_inserter(startTimesDifferences),
                         std::minus());
  for (const auto timeDifference : startTimesDifferences) {
    // This succeeds
    EXPECT_NEAR(static_cast<double>(INTERVAL.count()), timeDifference.count(),
                0.02);
  }
}