Class MalignWorker

test/async_progress_worker.cc:232–300

};

class MalignWorker : public AsyncProgressWorker<ProgressData> {
 public:
  static void DoWork(const CallbackInfo& info) {
    Function cb = info[0].As<Function>();
    Function progress = info[1].As<Function>();

    MalignWorker* worker =
        new MalignWorker(cb, progress, "TestResource", Object::New(info.Env()));
    worker->Queue();
  }

 protected:
  void Execute(const ExecutionProgress& progress) override {
    {
      std::unique_lock<std::mutex> lock(_cvm);
      // Testing a nullptr send is acceptable.
      progress.Send(nullptr, 0);
      _cv.wait(lock, [this] { return _test_case_count == 1; });
    }
    {
      std::unique_lock<std::mutex> lock(_cvm);
      progress.Signal();
      _cv.wait(lock, [this] { return _test_case_count == 2; });
    }
    // Testing busy looping on send doesn't trigger unexpected empty data
    // OnProgress call.
    for (size_t i = 0; i < 1000000; i++) {
      ProgressData data{0};
      progress.Send(&data, 1);
    }
  }

  void OnProgress(const ProgressData* /* data */, size_t count) override {
    Napi::Env env = Env();
    {
      std::lock_guard<std::mutex> lock(_cvm);
      _test_case_count++;
    }
    bool error = false;
    Napi::String reason = Napi::String::New(env, "No error");
    if (_test_case_count <= 2 && count != 0) {
      error = true;
      reason =
          Napi::String::New(env, "expect 0 count of data on 1st and 2nd call");
    }
    if (_test_case_count > 2 && count != 1) {
      error = true;
      reason = Napi::String::New(
          env, "expect 1 count of data on non-1st and non-2nd call");
    }
    _progress.MakeCallback(Receiver().Value(),
                           {Napi::Boolean::New(env, error), reason});
    _cv.notify_one();
  }

 private:
  MalignWorker(Function cb,
               Function progress,