koffi 2.4.2 → 2.5.0-beta.2

package/src/koffi/src/ffi.hh

@@ -198,7 +198,7 @@ struct ParameterInfo {
     int8_t vec_bytes; // ARM64
 #elif defined(__i386__) || defined(_M_IX86)
     bool trivial; // Only matters for return value
-    bool fast;
+    int8_t fast;
 #elif __riscv_xlen == 64
     bool use_memory;
     int8_t gpr_count;
@@ -273,6 +273,8 @@ struct InstanceData {
     const TypeInfo *char_type;
     const TypeInfo *char16_type;
 
+    Napi::Symbol active_symbol;
+
     std::mutex memories_mutex;
     LocalArray<InstanceMemory *, 9> memories;
     int temporaries = 0;

package/src/koffi/src/util.cc

@@ -58,14 +58,19 @@ Napi::Function MagicUnion::InitClass(Napi::Env env, const TypeInfo *type)
 MagicUnion::MagicUnion(const Napi::CallbackInfo &info)
     : Napi::ObjectWrap<MagicUnion>(info), type((const TypeInfo *)info.Data())
 {
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    active_symbol = instance->active_symbol;
 }
 
 void MagicUnion::SetRaw(const uint8_t *ptr)
 {
-    raw = ptr;
+    raw.RemoveFrom(0);
+    raw.Append(MakeSpan(ptr, type->size));
 
+    Value().Set(active_symbol, Env().Undefined());
     active_idx = -1;
-    Value().Set("__active", Env().Undefined());
 }
 
 Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
@@ -76,18 +81,18 @@ Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
     Napi::Value value;
 
     if (idx == active_idx) {
-        value = Value().Get("__active");
+        value = Value().Get(active_symbol);
     } else {
         Napi::Env env = info.Env();
 
-        if (RG_UNLIKELY(!raw)) {
+        if (RG_UNLIKELY(!raw.len)) {
             ThrowError<Napi::Error>(env, "Cannont convert %1 union value", active_idx < 0 ? "empty" : "assigned");
             return env.Null();
         }
 
-        value = Decode(env, raw, member.type);
+        value = Decode(env, raw.ptr, member.type);
 
-        Value().Set("__active", value);
+        Value().Set(active_symbol, value);
         active_idx = idx;
     }
 
@@ -99,10 +104,10 @@ void MagicUnion::Setter(const Napi::CallbackInfo &info, const Napi::Value &value
 {
     Size idx = (Size)info.Data();
 
-    Value().Set("__active", value);
+    Value().Set(active_symbol, value);
     active_idx = idx;
 
-    raw = nullptr;
+    raw.Clear();
 }
 
 const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
@@ -272,10 +277,11 @@ const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int
         char name_buf[256];
         Fmt(name_buf, "%1%2*", ref->name, EndsWith(ref->name, "*") ? "" : " ");
 
-        TypeInfo *type = (TypeInfo *)instance->types_map.FindValue(name_buf, nullptr);
+        bool inserted;
+        auto bucket = instance->types_map.TrySetDefault(name_buf, &inserted);
 
-        if (!type) {
-            type = instance->types.AppendDefault();
+        if (inserted) {
+            TypeInfo *type = instance->types.AppendDefault();
 
             type->name = DuplicateString(name_buf, &instance->str_alloc).ptr;
 
@@ -291,10 +297,11 @@ const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int
                 type->ref.proto = ref->ref.proto;
             }
 
-            instance->types_map.Set(type->name, type);
+            bucket->key = type->name;
+            bucket->value = type;
         }
 
-        ref = type;
+        ref = bucket->value;
     }
 
     return ref;

package/src/koffi/src/util.hh

@@ -38,18 +38,21 @@ extern const int MagicUnionMarker;
 class MagicUnion: public Napi::ObjectWrap<MagicUnion> {
     const TypeInfo *type;
 
+    napi_value active_symbol;
     Size active_idx = -1;
-    const uint8_t *raw = nullptr;
+
+    HeapArray<uint8_t> raw;
 
 public:
     static Napi::Function InitClass(Napi::Env env, const TypeInfo *type);
 
     MagicUnion(const Napi::CallbackInfo &info);
 
+    const TypeInfo *GetType() { return type; }
     const RecordMember *GetMember() const { return (active_idx >= 0) ? &type->members[active_idx] : nullptr; }
 
     void SetRaw(const uint8_t *ptr);
-    const uint8_t *GetRaw() const { return raw; }
+    const uint8_t *GetRaw() const { return raw.ptr; }
 
 private:
     Napi::Value Getter(const Napi::CallbackInfo &info);

package/vendor/node-addon-api/CHANGELOG.md

@@ -1,5 +1,36 @@
 # node-addon-api Changelog
 
+## 2023-06-13 Version 7.0.0, @KevinEady
+
+### Notable changes
+
+#### API
+
+- Drop support for Node.js v14.x and v19.x.
+- Ensure native receiver exists when calling instance methods and properties.
+- Fix issue when creating `Napi::Error` instances that wrap primitives values.
+
+#### TEST
+
+- Added tests for `Napi::AsyncProgressQueueWorker<T>` class.
+- Added tests for `Napi::AsyncProgressWorker<T>` class.
+
+### Documentation
+
+- Added documentation for `Napi::Value::IsBigInt()`.
+
+### Commits
+
+* \[[`de5c899400`](https://github.com/nodejs/node-addon-api/commit/de5c899400)] - **doc,chore**: drop support for Node.js v14, v19 (Kevin Eady) [#1324](https://github.com/nodejs/node-addon-api/pull/1324)
+* \[[`3083b7f148`](https://github.com/nodejs/node-addon-api/commit/3083b7f148)] - \[StepSecurity] Apply security best practices (StepSecurity Bot) [#1308](https://github.com/nodejs/node-addon-api/pull/1308)
+* \[[`a198e24a15`](https://github.com/nodejs/node-addon-api/commit/a198e24a15)] - \[Test] Add tests for async progress queue worker (Jack) [#1316](https://github.com/nodejs/node-addon-api/pull/1316)
+* \[[`665f4aa845`](https://github.com/nodejs/node-addon-api/commit/665f4aa845)] - **doc**: add missing Value::IsBigInt (Kevin Eady) [#1319](https://github.com/nodejs/node-addon-api/pull/1319)
+* \[[`358b2d3b4f`](https://github.com/nodejs/node-addon-api/commit/358b2d3b4f)] - **doc**: complete code curly braces  in async\_worker.md (wanlu) [#1317](https://github.com/nodejs/node-addon-api/pull/1317)
+* \[[`858942ce31`](https://github.com/nodejs/node-addon-api/commit/858942ce31)] - **src**: avoid calling into C++ with a null this (Caleb Hearon) [#1313](https://github.com/nodejs/node-addon-api/pull/1313)
+* \[[`64f6515331`](https://github.com/nodejs/node-addon-api/commit/64f6515331)] - **src**: handle failure during error wrap of primitive (Gabriel Schulhof) [#1310](https://github.com/nodejs/node-addon-api/pull/1310)
+* \[[`dfad6b45fe`](https://github.com/nodejs/node-addon-api/commit/dfad6b45fe)] - \[test] Add test coverage for AsyncProgressWorker (Jack) [#1307](https://github.com/nodejs/node-addon-api/pull/1307)
+* \[[`0e34f22839`](https://github.com/nodejs/node-addon-api/commit/0e34f22839)] - **release**: v6.1.0. (Nicola Del Gobbo)
+
 ## 2023-04-20 Version 6.1.0, @NickNaso
 
 ### Notable changes

package/vendor/node-addon-api/README.md

@@ -70,7 +70,7 @@ and node-addon-api.
 - **[Contributors](#contributors)**
 - **[License](#license)**
 
-## **Current version: 6.1.0**
+## **Current version: 7.0.0**
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
 
@@ -83,7 +83,7 @@ This allows addons built with it to run with Node.js versions which support the
 **However** the node-addon-api support model is to support only the active LTS Node.js versions. This means that
 every year there will be a new major which drops support for the Node.js LTS version which has gone out of service.
 
-The oldest Node.js version supported by the current version of node-addon-api is Node.js 14.x.
+The oldest Node.js version supported by the current version of node-addon-api is Node.js 16.x.
 
 ## Setup
   - [Installation and usage](doc/setup.md)
@@ -275,6 +275,7 @@ available:
 ![Node-API v6 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v6%20Badge.svg)
 ![Node-API v7 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v7%20Badge.svg)
 ![Node-API v8 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v8%20Badge.svg)
+![Node-API v9 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v9%20Badge.svg)
 ![Node-API Experimental Version Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20Experimental%20Version%20Badge.svg)
 
 ## **Contributing**

package/vendor/node-addon-api/doc/async_worker.md

@@ -418,6 +418,7 @@ Value Echo(const CallbackInfo& info) {
     EchoWorker* wk = new EchoWorker(cb, in);
     wk->Queue();
     return info.Env().Undefined();
+}
 ```
 
 Using the implementation of a `Napi::AsyncWorker` is straight forward. You only

package/vendor/node-addon-api/doc/creating_a_release.md

@@ -60,3 +60,24 @@ and that the correct version is installed.
 and close the issue.
 
 * Tweet that the release has been created.
+
+## Optional Steps
+
+Depending on circumstances for the release, additional steps may be required to
+support the release process.
+
+### Major Releases to Drop Support Node.js Versions
+
+`node-addon-api` provides support for Node.js versions following the same
+[release schedule](https://nodejs.dev/en/about/releases/): once a Node.js
+version leaves maintenance mode, the next major version of `node-addon-api`
+published will drop support for that version. These are the steps to follow to
+drop support for a Node.js version:
+
+* Update minimum version supported in documentation ([README.md](../README.md))
+
+* Remove from GitHub actions ([ci.yml](../.github/workflows/ci.yml) and
+  [ci-win.yml](../.github/workflows/ci-win.yml))
+
+* Remove from Jenkins CI ([node-test-node-addon-api-LTS versions
+  [Jenkins]](https://ci.nodejs.org/view/x%20-%20Abi%20stable%20module%20API/job/node-test-node-addon-api-LTS%20versions/))

package/vendor/node-addon-api/doc/value.md

@@ -141,6 +141,13 @@ bool Napi::Value::IsArrayBuffer() const;
 Returns `true` if the underlying value is a JavaScript `Napi::ArrayBuffer` or
 `false` otherwise.
 
+```cpp
+bool Napi::Value::IsBigInt() const;
+```
+
+Returns `true` if the underlying value is a JavaScript `Napi::BigInt` or `false`
+otherwise.
+
 ### IsBoolean
 
 ```cpp

package/vendor/node-addon-api/napi-inl.h

@@ -165,7 +165,7 @@ napi_value TemplatedInstanceCallback(napi_env env,
   return details::WrapCallback([&] {
     CallbackInfo cbInfo(env, info);
     T* instance = T::Unwrap(cbInfo.This().As<Object>());
-    return (instance->*UnwrapCallback)(cbInfo);
+    return instance ? (instance->*UnwrapCallback)(cbInfo) : Napi::Value();
   });
 }
 
@@ -175,7 +175,7 @@ napi_value TemplatedInstanceVoidCallback(napi_env env, napi_callback_info info)
   return details::WrapCallback([&] {
     CallbackInfo cbInfo(env, info);
     T* instance = T::Unwrap(cbInfo.This().As<Object>());
-    (instance->*UnwrapCallback)(cbInfo);
+    if (instance) (instance->*UnwrapCallback)(cbInfo);
     return nullptr;
   });
 }
@@ -2937,6 +2937,22 @@ inline Error::Error(napi_env env, napi_value value)
           nullptr};
 
       status = napi_define_properties(env, wrappedErrorObj, 1, &wrapObjFlag);
+#ifdef NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS
+      if (status == napi_pending_exception) {
+        // Test if the pending exception was reported because the environment is
+        // shutting down. We assume that a status of napi_pending_exception
+        // coupled with the absence of an actual pending exception means that
+        // the environment is shutting down. If so, we replace the
+        // napi_pending_exception status with napi_ok.
+        bool is_exception_pending = false;
+        status = napi_is_exception_pending(env, &is_exception_pending);
+        if (status == napi_ok && !is_exception_pending) {
+          status = napi_ok;
+        } else {
+          status = napi_pending_exception;
+        }
+      }
+#endif  // NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS
       NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_define_properties");
 
       // Create a reference on the newly wrapped object
@@ -4340,7 +4356,7 @@ inline napi_value InstanceWrap<T>::InstanceVoidMethodCallbackWrapper(
     callbackInfo.SetData(callbackData->data);
     T* instance = T::Unwrap(callbackInfo.This().As<Object>());
     auto cb = callbackData->callback;
-    (instance->*cb)(callbackInfo);
+    if (instance) (instance->*cb)(callbackInfo);
     return nullptr;
   });
 }
@@ -4355,7 +4371,7 @@ inline napi_value InstanceWrap<T>::InstanceMethodCallbackWrapper(
     callbackInfo.SetData(callbackData->data);
     T* instance = T::Unwrap(callbackInfo.This().As<Object>());
     auto cb = callbackData->callback;
-    return (instance->*cb)(callbackInfo);
+    return instance ? (instance->*cb)(callbackInfo) : Napi::Value();
   });
 }
 
@@ -4369,7 +4385,7 @@ inline napi_value InstanceWrap<T>::InstanceGetterCallbackWrapper(
     callbackInfo.SetData(callbackData->data);
     T* instance = T::Unwrap(callbackInfo.This().As<Object>());
     auto cb = callbackData->getterCallback;
-    return (instance->*cb)(callbackInfo);
+    return instance ? (instance->*cb)(callbackInfo) : Napi::Value();
   });
 }
 
@@ -4383,7 +4399,7 @@ inline napi_value InstanceWrap<T>::InstanceSetterCallbackWrapper(
     callbackInfo.SetData(callbackData->data);
     T* instance = T::Unwrap(callbackInfo.This().As<Object>());
     auto cb = callbackData->setterCallback;
-    (instance->*cb)(callbackInfo, callbackInfo[0]);
+    if (instance) (instance->*cb)(callbackInfo, callbackInfo[0]);
     return nullptr;
   });
 }
@@ -4395,7 +4411,7 @@ inline napi_value InstanceWrap<T>::WrappedMethod(
   return details::WrapCallback([&] {
     const CallbackInfo cbInfo(env, info);
     T* instance = T::Unwrap(cbInfo.This().As<Object>());
-    (instance->*method)(cbInfo, cbInfo[0]);
+    if (instance) (instance->*method)(cbInfo, cbInfo[0]);
     return nullptr;
   });
 }

package/vendor/node-addon-api/package.json

@@ -399,6 +399,14 @@
     {
       "name": "Feng Yu",
       "url": "https://github.com/F3n67u"
+    },
+    {
+      "name": "wanlu wang",
+      "url": "https://github.com/wanlu"
+    },
+    {
+      "name": "Caleb Hearon",
+      "url": "https://github.com/chearon"
     }
   ],
   "description": "Node.js API (Node-API)",
@@ -459,6 +467,6 @@
     "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
   },
   "pre-commit": "lint",
-  "version": "6.1.0",
+  "version": "7.0.0",
   "support": true
 }

package/vendor/node-addon-api/test/async_progress_queue_worker.cc

@@ -15,6 +15,158 @@ struct ProgressData {
   int32_t progress;
 };
 
+class TestWorkerWithNoCb : public AsyncProgressQueueWorker<ProgressData> {
+ public:
+  static void DoWork(const CallbackInfo& info) {
+    switch (info.Length()) {
+      case 1: {
+        Function cb = info[0].As<Function>();
+        TestWorkerWithNoCb* worker = new TestWorkerWithNoCb(info.Env(), cb);
+        worker->Queue();
+      } break;
+
+      case 2: {
+        std::string resName = info[0].As<String>();
+        Function cb = info[1].As<Function>();
+        TestWorkerWithNoCb* worker =
+            new TestWorkerWithNoCb(info.Env(), resName.c_str(), cb);
+        worker->Queue();
+      } break;
+
+      case 3: {
+        std::string resName = info[0].As<String>();
+        Object resObject = info[1].As<Object>();
+        Function cb = info[2].As<Function>();
+        TestWorkerWithNoCb* worker =
+            new TestWorkerWithNoCb(info.Env(), resName.c_str(), resObject, cb);
+        worker->Queue();
+      } break;
+
+      default:
+
+        break;
+    }
+  }
+
+ protected:
+  void Execute(const ExecutionProgress& progress) override {
+    ProgressData data{1};
+    progress.Send(&data, 1);
+  }
+
+  void OnProgress(const ProgressData*, size_t /* count */) override {
+    _cb.Call({});
+  }
+
+ private:
+  TestWorkerWithNoCb(Napi::Env env, Function cb)
+      : AsyncProgressQueueWorker(env) {
+    _cb.Reset(cb, 1);
+  }
+  TestWorkerWithNoCb(Napi::Env env, const char* resourceName, Function cb)
+      : AsyncProgressQueueWorker(env, resourceName) {
+    _cb.Reset(cb, 1);
+  }
+  TestWorkerWithNoCb(Napi::Env env,
+                     const char* resourceName,
+                     const Object& resourceObject,
+                     Function cb)
+      : AsyncProgressQueueWorker(env, resourceName, resourceObject) {
+    _cb.Reset(cb, 1);
+  }
+  FunctionReference _cb;
+};
+
+class TestWorkerWithRecv : public AsyncProgressQueueWorker<ProgressData> {
+ public:
+  static void DoWork(const CallbackInfo& info) {
+    switch (info.Length()) {
+      case 2: {
+        Object recv = info[0].As<Object>();
+        Function cb = info[1].As<Function>();
+        TestWorkerWithRecv* worker = new TestWorkerWithRecv(recv, cb);
+        worker->Queue();
+      } break;
+
+      case 3: {
+        Object recv = info[0].As<Object>();
+        Function cb = info[1].As<Function>();
+        std::string resName = info[2].As<String>();
+        TestWorkerWithRecv* worker =
+            new TestWorkerWithRecv(recv, cb, resName.c_str());
+        worker->Queue();
+      } break;
+
+      case 4: {
+        Object recv = info[0].As<Object>();
+        Function cb = info[1].As<Function>();
+        std::string resName = info[2].As<String>();
+        Object resObject = info[3].As<Object>();
+        TestWorkerWithRecv* worker =
+            new TestWorkerWithRecv(recv, cb, resName.c_str(), resObject);
+        worker->Queue();
+      } break;
+
+      default:
+
+        break;
+    }
+  }
+
+ protected:
+  void Execute(const ExecutionProgress&) override {}
+
+  void OnProgress(const ProgressData*, size_t /* count */) override {}
+
+ private:
+  TestWorkerWithRecv(const Object& recv, const Function& cb)
+      : AsyncProgressQueueWorker(recv, cb) {}
+  TestWorkerWithRecv(const Object& recv,
+                     const Function& cb,
+                     const char* resourceName)
+      : AsyncProgressQueueWorker(recv, cb, resourceName) {}
+  TestWorkerWithRecv(const Object& recv,
+                     const Function& cb,
+                     const char* resourceName,
+                     const Object& resourceObject)
+      : AsyncProgressQueueWorker(recv, cb, resourceName, resourceObject) {}
+};
+
+class TestWorkerWithCb : public AsyncProgressQueueWorker<ProgressData> {
+ public:
+  static void DoWork(const CallbackInfo& info) {
+    switch (info.Length()) {
+      case 1: {
+        Function cb = info[0].As<Function>();
+        TestWorkerWithCb* worker = new TestWorkerWithCb(cb);
+        worker->Queue();
+      } break;
+
+      case 2: {
+        Function cb = info[0].As<Function>();
+        std::string asyncResName = info[1].As<String>();
+        TestWorkerWithCb* worker =
+            new TestWorkerWithCb(cb, asyncResName.c_str());
+        worker->Queue();
+      } break;
+
+      default:
+
+        break;
+    }
+  }
+
+ protected:
+  void Execute(const ExecutionProgress&) override {}
+
+  void OnProgress(const ProgressData*, size_t /* count */) override {}
+
+ private:
+  TestWorkerWithCb(Function cb) : AsyncProgressQueueWorker(cb) {}
+  TestWorkerWithCb(Function cb, const char* res_name)
+      : AsyncProgressQueueWorker(cb, res_name) {}
+};
+
 class TestWorker : public AsyncProgressQueueWorker<ProgressData> {
  public:
   static Napi::Value CreateWork(const CallbackInfo& info) {
@@ -87,6 +239,9 @@ Object InitAsyncProgressQueueWorker(Env env) {
   Object exports = Object::New(env);
   exports["createWork"] = Function::New(env, TestWorker::CreateWork);
   exports["queueWork"] = Function::New(env, TestWorker::QueueWork);
+  exports["runWorkerNoCb"] = Function::New(env, TestWorkerWithNoCb::DoWork);
+  exports["runWorkerWithRecv"] = Function::New(env, TestWorkerWithRecv::DoWork);
+  exports["runWorkerWithCb"] = Function::New(env, TestWorkerWithCb::DoWork);
   return exports;
 }
 

package/vendor/node-addon-api/test/async_progress_queue_worker.js

@@ -4,10 +4,144 @@ const common = require('./common');
 const assert = require('assert');
 
 module.exports = common.runTest(test);
+const nodeVersion = process.versions.node.split('.')[0];
+
+let asyncHooks;
+function checkAsyncHooks () {
+  if (nodeVersion >= 8) {
+    if (asyncHooks === undefined) {
+      asyncHooks = require('async_hooks');
+    }
+    return true;
+  }
+  return false;
+}
 
 async function test ({ asyncprogressqueueworker }) {
   await success(asyncprogressqueueworker);
   await fail(asyncprogressqueueworker);
+
+  await asyncProgressWorkerCallbackOverloads(asyncprogressqueueworker.runWorkerWithCb);
+  await asyncProgressWorkerRecvOverloads(asyncprogressqueueworker.runWorkerWithRecv);
+  await asyncProgressWorkerNoCbOverloads(asyncprogressqueueworker.runWorkerNoCb);
+}
+
+async function asyncProgressWorkerCallbackOverloads (bindingFunction) {
+  bindingFunction(common.mustCall());
+  if (!checkAsyncHooks()) {
+    return;
+  }
+
+  const hooks = common.installAysncHooks('cbResources');
+
+  const triggerAsyncId = asyncHooks.executionAsyncId();
+  await new Promise((resolve, reject) => {
+    bindingFunction(common.mustCall(), 'cbResources');
+    hooks.then(actual => {
+      assert.deepStrictEqual(actual, [
+        {
+          eventName: 'init',
+          type: 'cbResources',
+          triggerAsyncId: triggerAsyncId,
+          resource: {}
+        },
+        { eventName: 'before' },
+        { eventName: 'after' },
+        { eventName: 'destroy' }
+      ]);
+      resolve();
+    }).catch((err) => reject(err));
+  });
+}
+
+async function asyncProgressWorkerRecvOverloads (bindingFunction) {
+  const recvObject = {
+    a: 4
+  };
+
+  function cb () {
+    assert.strictEqual(this.a, recvObject.a);
+  }
+
+  bindingFunction(recvObject, common.mustCall(cb));
+  if (!checkAsyncHooks()) {
+    return;
+  }
+  const asyncResources = [
+    { resName: 'cbRecvResources', resObject: {} },
+    { resName: 'cbRecvResourcesObject', resObject: { foo: 'bar' } }
+  ];
+
+  for (const asyncResource of asyncResources) {
+    const asyncResName = asyncResource.resName;
+    const asyncResObject = asyncResource.resObject;
+
+    const hooks = common.installAysncHooks(asyncResource.resName);
+    const triggerAsyncId = asyncHooks.executionAsyncId();
+    await new Promise((resolve, reject) => {
+      if (Object.keys(asyncResObject).length === 0) {
+        bindingFunction(recvObject, common.mustCall(cb), asyncResName);
+      } else {
+        bindingFunction(recvObject, common.mustCall(cb), asyncResName, asyncResObject);
+      }
+
+      hooks.then(actual => {
+        assert.deepStrictEqual(actual, [
+          {
+            eventName: 'init',
+            type: asyncResName,
+            triggerAsyncId: triggerAsyncId,
+            resource: asyncResObject
+          },
+          { eventName: 'before' },
+          { eventName: 'after' },
+          { eventName: 'destroy' }
+        ]);
+        resolve();
+      }).catch((err) => reject(err));
+    });
+  }
+}
+
+async function asyncProgressWorkerNoCbOverloads (bindingFunction) {
+  bindingFunction(common.mustCall());
+  if (!checkAsyncHooks()) {
+    return;
+  }
+  const asyncResources = [
+    { resName: 'noCbResources', resObject: {} },
+    { resName: 'noCbResourcesObject', resObject: { foo: 'bar' } }
+  ];
+
+  for (const asyncResource of asyncResources) {
+    const asyncResName = asyncResource.resName;
+    const asyncResObject = asyncResource.resObject;
+
+    const hooks = common.installAysncHooks(asyncResource.resName);
+    const triggerAsyncId = asyncHooks.executionAsyncId();
+    await new Promise((resolve, reject) => {
+      if (Object.keys(asyncResObject).length === 0) {
+        bindingFunction(asyncResName, common.mustCall(() => {}));
+      } else {
+        bindingFunction(asyncResName, asyncResObject, common.mustCall(() => {}));
+      }
+
+      hooks.then(actual => {
+        assert.deepStrictEqual(actual, [
+          {
+            eventName: 'init',
+            type: asyncResName,
+            triggerAsyncId: triggerAsyncId,
+            resource: asyncResObject
+          },
+          { eventName: 'before' },
+          { eventName: 'after' },
+          { eventName: 'destroy' }
+        ]);
+        resolve();
+      }).catch((err) => reject(err));
+    });
+  }
 }
 
 function success (binding) {