Method getOutput

bolt/exec/tests/DriverTest.cpp:697–731

    params[i].maxDrivers = kThreadsPerTask;
  }
  std::vector<int32_t> counters(kNumTasks, 0);
  std::vector<std::thread> threads;
  threads.reserve(kNumTasks);
  for (int32_t i = 0; i < kNumTasks; ++i) {
    threads.push_back(std::thread([this, &params, &counters, i]() {
      readResults(params[i], ResultOperation::kYield, 10'000, &counters[i], i);
    }));
  }
  for (int32_t i = 0; i < kNumTasks; ++i) {
    threads[i].join();
    EXPECT_WITH_DELAY(stateFutures_.at(i).isReady());
    EXPECT_EQ(counters[i], kThreadsPerTask * hits);
  }
}

// A testing Operator that periodically does one of the following:
//
// 1. Blocks and registers a resume that continues the Driver after a timed
// pause. This simulates blocking to wait for exchange or consumer.
//
// 2. Enters a suspended section where the Driver is on thread but is not
// counted as running and is therefore instantaneously cancellable and pausable.
// Comes back on thread after a timed pause. This simulates an RPC to an out of
// process service.
//
// 3.  Enters a suspended section where this pauses and resumes random Tasks,
// including its own Task. This simulates making Tasks release memory under
// memory contention, checkpointing Tasks for migration or fault tolerance and
// other process-wide coordination activities.
//
// These situations will occur with arbitrary concurrency and sequence and must
// therefore be in one test to check against deadlocks.
class TestingPauser : public Operator {
 public:
  TestingPauser(
      DriverCtx* ctx,
      int32_t id,
      std::shared_ptr<const TestingPauserNode> node,