#include "napi.h"

// A variant of TestWorker wherein destruction is suppressed. That is, instances

// are not destroyed during the `OnOK` callback. They must be explicitly

// destroyed.

using namespace Napi;

namespace {

class PersistentTestWorker : public AsyncWorker {

public:

static PersistentTestWorker* current_worker;

static void DoWork(const CallbackInfo& info) {

bool succeed = info[0].As<Boolean>();

Function cb = info[1].As<Function>();

PersistentTestWorker* worker = new PersistentTestWorker(cb, "TestResource");

current_worker = worker;

worker->SuppressDestruct();

worker->_succeed = succeed;

worker->Queue();

}

static Value GetWorkerGone(const CallbackInfo& info) {

return Boolean::New(info.Env(), current_worker == nullptr);

}

static void DeleteWorker(const CallbackInfo& info) {

(void) info;

delete current_worker;

}

~PersistentTestWorker() {

current_worker = nullptr;

}

protected:

void Execute() override {

if (!_succeed) {

SetError("test error");

}

}

private:

PersistentTestWorker(Function cb,

const char* resource_name)

: AsyncWorker(cb, resource_name) {}

bool _succeed;

};

PersistentTestWorker* PersistentTestWorker::current_worker = nullptr;

} // end of anonymous namespace

Object InitPersistentAsyncWorker(Env env) {

Object exports = Object::New(env);

exports["doWork"] = Function::New(env, PersistentTestWorker::DoWork);

exports.DefineProperty(

PropertyDescriptor::Accessor(env, exports, "workerGone",

PersistentTestWorker::GetWorkerGone));

exports["deleteWorker"] =

Function::New(env, PersistentTestWorker::DeleteWorker);

return exports;

}