koffi 2.3.4 → 2.3.6-beta.1

package/vendor/node-addon-api/test/basic_types/number.js

@@ -1,10 +1,11 @@
+/* eslint-disable no-lone-blocks */
 'use strict';
 
 const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   const MIN_INT32 = -2147483648;
   const MAX_INT32 = 2147483647;
   const MIN_UINT32 = 0;
@@ -16,9 +17,9 @@ function test(binding) {
   const MIN_DOUBLE = binding.basic_types_number.minDouble();
   const MAX_DOUBLE = binding.basic_types_number.maxDouble();
 
-  function randomRangeTestForInteger(min, max, converter) {
-    for (let i = min; i < max; i+= Math.floor(Math.random() * max / 100)) {
-        assert.strictEqual(i, converter(i));
+  function randomRangeTestForInteger (min, max, converter) {
+    for (let i = min; i < max; i += Math.floor(Math.random() * max / 100)) {
+      assert.strictEqual(i, converter(i));
     }
   }
 
@@ -96,19 +97,19 @@ function test(binding) {
 
   // Construction test
   {
-    assert.strictEqual(binding.basic_types_number.createEmptyNumber(), true);
-    randomRangeTestForInteger(MIN_INT32, MAX_INT32, binding.basic_types_number.createNumberFromExistingValue);
-    assert.strictEqual(MIN_INT32, binding.basic_types_number.createNumberFromExistingValue(MIN_INT32));
-    assert.strictEqual(MAX_INT32, binding.basic_types_number.createNumberFromExistingValue(MAX_INT32));
-    randomRangeTestForInteger(MIN_UINT32, MAX_UINT32, binding.basic_types_number.createNumberFromExistingValue);
-    assert.strictEqual(MIN_UINT32, binding.basic_types_number.createNumberFromExistingValue(MIN_UINT32));
-    assert.strictEqual(MAX_UINT32, binding.basic_types_number.createNumberFromExistingValue(MAX_UINT32));
-    randomRangeTestForInteger(MIN_INT64, MAX_INT64, binding.basic_types_number.createNumberFromExistingValue);
-    assert.strictEqual(MIN_INT64, binding.basic_types_number.createNumberFromExistingValue(MIN_INT64));
-    assert.strictEqual(MAX_INT64, binding.basic_types_number.createNumberFromExistingValue(MAX_INT64));
-    assert.strictEqual(MIN_FLOAT, binding.basic_types_number.createNumberFromExistingValue(MIN_FLOAT));
-    assert.strictEqual(MAX_FLOAT, binding.basic_types_number.createNumberFromExistingValue(MAX_FLOAT));
-    assert.strictEqual(MIN_DOUBLE, binding.basic_types_number.createNumberFromExistingValue(MIN_DOUBLE));
-    assert.strictEqual(MAX_DOUBLE, binding.basic_types_number.createNumberFromExistingValue(MAX_DOUBLE));
+    assert.strictEqual(binding.basic_types_number.createEmptyNumber(), true);
+    randomRangeTestForInteger(MIN_INT32, MAX_INT32, binding.basic_types_number.createNumberFromExistingValue);
+    assert.strictEqual(MIN_INT32, binding.basic_types_number.createNumberFromExistingValue(MIN_INT32));
+    assert.strictEqual(MAX_INT32, binding.basic_types_number.createNumberFromExistingValue(MAX_INT32));
+    randomRangeTestForInteger(MIN_UINT32, MAX_UINT32, binding.basic_types_number.createNumberFromExistingValue);
+    assert.strictEqual(MIN_UINT32, binding.basic_types_number.createNumberFromExistingValue(MIN_UINT32));
+    assert.strictEqual(MAX_UINT32, binding.basic_types_number.createNumberFromExistingValue(MAX_UINT32));
+    randomRangeTestForInteger(MIN_INT64, MAX_INT64, binding.basic_types_number.createNumberFromExistingValue);
+    assert.strictEqual(MIN_INT64, binding.basic_types_number.createNumberFromExistingValue(MIN_INT64));
+    assert.strictEqual(MAX_INT64, binding.basic_types_number.createNumberFromExistingValue(MAX_INT64));
+    assert.strictEqual(MIN_FLOAT, binding.basic_types_number.createNumberFromExistingValue(MIN_FLOAT));
+    assert.strictEqual(MAX_FLOAT, binding.basic_types_number.createNumberFromExistingValue(MAX_FLOAT));
+    assert.strictEqual(MIN_DOUBLE, binding.basic_types_number.createNumberFromExistingValue(MIN_DOUBLE));
+    assert.strictEqual(MAX_DOUBLE, binding.basic_types_number.createNumberFromExistingValue(MAX_DOUBLE));
   }
 }

package/vendor/node-addon-api/test/basic_types/value.cc

@@ -12,7 +12,44 @@ Value CreateExternal(const CallbackInfo& info) {
   return External<int>::New(info.Env(), &testData);
 }
 
-} // end anonymous namespace
+}  // end anonymous namespace
+
+static Value StrictlyEquals(const CallbackInfo& info) {
+  bool strictlyEquals = info[0].StrictEquals(info[1]);
+  return Boolean::New(info.Env(), strictlyEquals);
+}
+
+// tests the  '==' overload
+static Value StrictEqualsOverload(const CallbackInfo& info) {
+  bool strictlyEquals = info[0] == info[1];
+  return Boolean::New(info.Env(), strictlyEquals);
+}
+
+// tests the '!=' overload
+static Value StrictlyNotEqualsOverload(const CallbackInfo& info) {
+  bool strictlyEquals = info[0] != info[1];
+  return Boolean::New(info.Env(), strictlyEquals);
+}
+
+static Value ValueReturnsCorrectEnv(const CallbackInfo& info) {
+  Value testValue = CreateExternal(info);
+  return Boolean::New(info.Env(), testValue.Env() == info.Env());
+}
+
+static Value EmptyValueReturnNullPtrOnCast(const CallbackInfo& info) {
+  Value emptyValue;
+  bool isNullPtr = static_cast<napi_value>(emptyValue) == nullptr;
+  return Boolean::New(info.Env(), isNullPtr);
+}
+
+static Value NonEmptyValueReturnValOnCast(const CallbackInfo& info) {
+  Value boolValue = Value::From(info.Env(), true);
+  return Boolean::New(info.Env(), static_cast<napi_value>(boolValue));
+}
+
+static Value CreateNonEmptyValue(const CallbackInfo& info) {
+  return Napi::Value(info.Env(), String::New(info.Env(), "non_empty_val"));
+}
 
 static Value IsEmpty(const CallbackInfo& info) {
   Value value;
@@ -114,6 +151,20 @@ Object InitBasicTypesValue(Env env) {
   exports["toString"] = Function::New(env, ToString);
   exports["toObject"] = Function::New(env, ToObject);
 
+  exports["strictlyEquals"] = Function::New(env, StrictlyEquals);
+  exports["strictlyEqualsOverload"] = Function::New(env, StrictEqualsOverload);
+  exports["strictlyNotEqualsOverload"] =
+      Function::New(env, StrictlyNotEqualsOverload);
+
+  exports["assertValueReturnsCorrectEnv"] =
+      Function::New(env, ValueReturnsCorrectEnv);
+
+  exports["assertEmptyValReturnNullPtrOnCast"] =
+      Function::New(env, EmptyValueReturnNullPtrOnCast);
+  exports["assertNonEmptyReturnValOnCast"] =
+      Function::New(env, NonEmptyValueReturnValOnCast);
+
+  exports["createNonEmptyValue"] = Function::New(env, CreateNonEmptyValue);
   exports["createExternal"] = Function::New(env, CreateExternal);
 
   return exports;

package/vendor/node-addon-api/test/basic_types/value.js

@@ -4,33 +4,27 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   const externalValue = binding.basic_types_value.createExternal();
 
-  function isObject(value) {
+  function isObject (value) {
     return (typeof value === 'object' && value !== externalValue) ||
            (typeof value === 'function');
   }
 
-  function detailedTypeOf(value) {
+  function detailedTypeOf (value) {
     const type = typeof value;
-    if (type !== 'object')
-      return type;
+    if (type !== 'object') { return type; }
 
-    if (value === null)
-      return 'null';
+    if (value === null) { return 'null'; }
 
-    if (Array.isArray(value))
-      return 'array';
+    if (Array.isArray(value)) { return 'array'; }
 
-    if (value === externalValue)
-      return 'external';
+    if (value === externalValue) { return 'external'; }
 
-    if (!value.constructor)
-      return type;
+    if (!value.constructor) { return type; }
 
-    if (value instanceof ArrayBuffer)
-      return 'arraybuffer';
+    if (value instanceof ArrayBuffer) { return 'arraybuffer'; }
 
     if (ArrayBuffer.isView(value)) {
       if (value instanceof DataView) {
@@ -40,13 +34,12 @@ function test(binding) {
       }
     }
 
-    if (value instanceof Promise)
-      return 'promise';
+    if (value instanceof Promise) { return 'promise'; }
 
     return 'object';
   }
 
-  function typeCheckerTest(typeChecker, expectedType) {
+  function typeCheckerTest (typeChecker, expectedType) {
     const testValueList = [
       undefined,
       null,
@@ -58,7 +51,7 @@ function test(binding) {
       new ArrayBuffer(10),
       new Int32Array(new ArrayBuffer(12)),
       {},
-      function() {},
+      function () {},
       new Promise((resolve, reject) => {}),
       new DataView(new ArrayBuffer(12)),
       externalValue
@@ -73,7 +66,7 @@ function test(binding) {
     });
   }
 
-  function typeConverterTest(typeConverter, expectedType) {
+  function typeConverterTest (typeConverter, expectedType) {
     const testValueList = [
       true,
       false,
@@ -84,7 +77,7 @@ function test(binding) {
       new ArrayBuffer(10),
       new Int32Array(new ArrayBuffer(12)),
       {},
-      function() {},
+      function () {},
       new Promise((resolve, reject) => {})
     ];
 
@@ -100,8 +93,38 @@ function test(binding) {
     });
   }
 
+  function assertValueStrictlyEqual (value) {
+    const newValue = value.createNonEmptyValue();
+    assert(value.strictlyEquals(newValue, newValue));
+    assert(value.strictlyEqualsOverload(newValue, newValue));
+  }
+
+  function assertValueStrictlyNonEqual (value) {
+    const valueA = value.createNonEmptyValue();
+    const valueB = value.createExternal();
+    assert(value.strictlyNotEqualsOverload(valueA, valueB));
+  }
+
+  function assertValueReturnsCorrectEnv (value) {
+    assert(value.assertValueReturnsCorrectEnv());
+  }
+
+  function assertEmptyValueNullPtrOnCast (value) {
+    assert(value.assertEmptyValReturnNullPtrOnCast());
+  }
+
+  function assertNonEmptyReturnValOnCast (value) {
+    assert(value.assertNonEmptyReturnValOnCast());
+  }
+
   const value = binding.basic_types_value;
 
+  assertValueStrictlyEqual(value);
+  assertValueStrictlyNonEqual(value);
+  assertValueReturnsCorrectEnv(value);
+  assertEmptyValueNullPtrOnCast(value);
+  assertNonEmptyReturnValOnCast(value);
+
   typeCheckerTest(value.isUndefined, 'undefined');
   typeCheckerTest(value.isNull, 'null');
   typeCheckerTest(value.isBoolean, 'boolean');

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

@@ -59,7 +59,8 @@ Value TestWords(const CallbackInfo& info) {
   big.ToWords(&sign_bit, &word_count, words);
 
   if (word_count != expected_word_count) {
-    Error::New(info.Env(), "word count did not match").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "word count did not match")
+        .ThrowAsJavaScriptException();
     return BigInt();
   }
 

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

@@ -28,6 +28,7 @@ Object InitCallbackScope(Env env);
 #if (NAPI_VERSION > 4)
 Object InitDate(Env env);
 #endif
+Object InitCallbackInfo(Env env);
 Object InitDataView(Env env);
 Object InitDataViewReadWrite(Env env);
 Object InitEnvCleanup(Env env);
@@ -43,7 +44,7 @@ Object InitName(Env env);
 Object InitObject(Env env);
 #ifndef NODE_ADDON_API_DISABLE_DEPRECATED
 Object InitObjectDeprecated(Env env);
-#endif // !NODE_ADDON_API_DISABLE_DEPRECATED
+#endif  // !NODE_ADDON_API_DISABLE_DEPRECATED
 Object InitPromise(Env env);
 Object InitRunScript(Env env);
 #if (NAPI_VERSION > 3)
@@ -74,6 +75,7 @@ Object InitVersionManagement(Env env);
 Object InitThunkingManual(Env env);
 #if (NAPI_VERSION > 7)
 Object InitObjectFreezeSeal(Env env);
+Object InitObjectTypeTag(Env env);
 #endif
 
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
@@ -108,6 +110,7 @@ Object Init(Env env, Object exports) {
 #if (NAPI_VERSION > 2)
   exports.Set("callbackscope", InitCallbackScope(env));
 #endif
+  exports.Set("callbackInfo", InitCallbackInfo(env));
   exports.Set("dataview", InitDataView(env));
   exports.Set("dataview_read_write", InitDataView(env));
   exports.Set("dataview_read_write", InitDataViewReadWrite(env));
@@ -126,13 +129,14 @@ Object Init(Env env, Object exports) {
   exports.Set("object", InitObject(env));
 #ifndef NODE_ADDON_API_DISABLE_DEPRECATED
   exports.Set("object_deprecated", InitObjectDeprecated(env));
-#endif // !NODE_ADDON_API_DISABLE_DEPRECATED
+#endif  // !NODE_ADDON_API_DISABLE_DEPRECATED
   exports.Set("promise", InitPromise(env));
   exports.Set("run_script", InitRunScript(env));
   exports.Set("symbol", InitSymbol(env));
 #if (NAPI_VERSION > 3)
   exports.Set("threadsafe_function_ctx", InitThreadSafeFunctionCtx(env));
-  exports.Set("threadsafe_function_existing_tsfn", InitThreadSafeFunctionExistingTsfn(env));
+  exports.Set("threadsafe_function_existing_tsfn",
+              InitThreadSafeFunctionExistingTsfn(env));
   exports.Set("threadsafe_function_ptr", InitThreadSafeFunctionPtr(env));
   exports.Set("threadsafe_function_sum", InitThreadSafeFunctionSum(env));
   exports.Set("threadsafe_function_unref", InitThreadSafeFunctionUnref(env));
@@ -152,16 +156,18 @@ Object Init(Env env, Object exports) {
   exports.Set("typedarray", InitTypedArray(env));
   exports.Set("objectwrap", InitObjectWrap(env));
   exports.Set("objectwrapConstructorException",
-      InitObjectWrapConstructorException(env));
+              InitObjectWrapConstructorException(env));
   exports.Set("objectwrap_function", InitObjectWrapFunction(env));
   exports.Set("objectwrap_removewrap", InitObjectWrapRemoveWrap(env));
-  exports.Set("objectwrap_multiple_inheritance", InitObjectWrapMultipleInheritance(env));
+  exports.Set("objectwrap_multiple_inheritance",
+              InitObjectWrapMultipleInheritance(env));
   exports.Set("objectreference", InitObjectReference(env));
   exports.Set("reference", InitReference(env));
   exports.Set("version_management", InitVersionManagement(env));
   exports.Set("thunking_manual", InitThunkingManual(env));
 #if (NAPI_VERSION > 7)
   exports.Set("object_freeze_seal", InitObjectFreezeSeal(env));
+  exports.Set("object_type_tag", InitObjectTypeTag(env));
 #endif
 
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)

package/vendor/node-addon-api/test/binding.gyp

@@ -17,6 +17,7 @@
         'basic_types/number.cc',
         'basic_types/value.cc',
         'bigint.cc',
+        'callbackInfo.cc',
         'date.cc',
         'binding.cc',
         'buffer.cc',
@@ -46,11 +47,12 @@
         'object/has_property.cc',
         'object/object.cc',
         'object/object_freeze_seal.cc',
+        'object/object_type_tag.cc',
         'object/set_property.cc',
         'object/subscript_operator.cc',
         'promise.cc',
         'run_script.cc',
-        "symbol.cc",
+        'symbol.cc',
         'threadsafe_function/threadsafe_function_ctx.cc',
         'threadsafe_function/threadsafe_function_existing_tsfn.cc',
         'threadsafe_function/threadsafe_function_ptr.cc',

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

@@ -29,7 +29,8 @@ Value CreateBuffer(const CallbackInfo& info) {
   Buffer<uint16_t> buffer = Buffer<uint16_t>::New(info.Env(), testLength);
 
   if (buffer.Length() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
@@ -40,18 +41,18 @@ Value CreateBuffer(const CallbackInfo& info) {
 Value CreateExternalBuffer(const CallbackInfo& info) {
   finalizeCount = 0;
 
-  Buffer<uint16_t> buffer = Buffer<uint16_t>::New(
-    info.Env(),
-    testData,
-    testLength);
+  Buffer<uint16_t> buffer =
+      Buffer<uint16_t>::New(info.Env(), testData, testLength);
 
   if (buffer.Length() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
   if (buffer.Data() != testData) {
-    Error::New(info.Env(), "Incorrect buffer data.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer data.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
@@ -65,21 +66,20 @@ Value CreateExternalBufferWithFinalize(const CallbackInfo& info) {
   uint16_t* data = new uint16_t[testLength];
 
   Buffer<uint16_t> buffer = Buffer<uint16_t>::New(
-    info.Env(),
-    data,
-    testLength,
-    [](Env /*env*/, uint16_t* finalizeData) {
-      delete[] finalizeData;
-      finalizeCount++;
-    });
+      info.Env(), data, testLength, [](Env /*env*/, uint16_t* finalizeData) {
+        delete[] finalizeData;
+        finalizeCount++;
+      });
 
   if (buffer.Length() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
   if (buffer.Data() != data) {
-    Error::New(info.Env(), "Incorrect buffer data.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer data.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
@@ -94,22 +94,24 @@ Value CreateExternalBufferWithFinalizeHint(const CallbackInfo& info) {
 
   char* hint = nullptr;
   Buffer<uint16_t> buffer = Buffer<uint16_t>::New(
-    info.Env(),
-    data,
-    testLength,
-    [](Env /*env*/, uint16_t* finalizeData, char* /*finalizeHint*/) {
-      delete[] finalizeData;
-      finalizeCount++;
-    },
-    hint);
+      info.Env(),
+      data,
+      testLength,
+      [](Env /*env*/, uint16_t* finalizeData, char* /*finalizeHint*/) {
+        delete[] finalizeData;
+        finalizeCount++;
+      },
+      hint);
 
   if (buffer.Length() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
   if (buffer.Data() != data) {
-    Error::New(info.Env(), "Incorrect buffer data.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer data.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
@@ -120,21 +122,24 @@ Value CreateExternalBufferWithFinalizeHint(const CallbackInfo& info) {
 Value CreateBufferCopy(const CallbackInfo& info) {
   InitData(testData, testLength);
 
-  Buffer<uint16_t> buffer = Buffer<uint16_t>::Copy(
-    info.Env(), testData, testLength);
+  Buffer<uint16_t> buffer =
+      Buffer<uint16_t>::Copy(info.Env(), testData, testLength);
 
   if (buffer.Length() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
   if (buffer.Data() == testData) {
-    Error::New(info.Env(), "Copy should have different memory.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Copy should have different memory.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
   if (!VerifyData(buffer.Data(), buffer.Length())) {
-    Error::New(info.Env(), "Copy data is incorrect.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Copy data is incorrect.")
+        .ThrowAsJavaScriptException();
     return Value();
   }
 
@@ -143,28 +148,31 @@ Value CreateBufferCopy(const CallbackInfo& info) {
 
 void CheckBuffer(const CallbackInfo& info) {
   if (!info[0].IsBuffer()) {
-    Error::New(info.Env(), "A buffer was expected.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "A buffer was expected.")
+        .ThrowAsJavaScriptException();
     return;
   }
 
   Buffer<uint16_t> buffer = info[0].As<Buffer<uint16_t>>();
 
   if (buffer.Length() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
     return;
   }
 
   if (!VerifyData(buffer.Data(), testLength)) {
-    Error::New(info.Env(), "Incorrect buffer data.").ThrowAsJavaScriptException();
+    Error::New(info.Env(), "Incorrect buffer data.")
+        .ThrowAsJavaScriptException();
     return;
   }
 }
 
 Value GetFinalizeCount(const CallbackInfo& info) {
-   return Number::New(info.Env(), finalizeCount);
+  return Number::New(info.Env(), finalizeCount);
 }
 
-} // end anonymous namespace
+}  // end anonymous namespace
 
 Object InitBuffer(Env env) {
   Object exports = Object::New(env);
@@ -172,9 +180,9 @@ Object InitBuffer(Env env) {
   exports["createBuffer"] = Function::New(env, CreateBuffer);
   exports["createExternalBuffer"] = Function::New(env, CreateExternalBuffer);
   exports["createExternalBufferWithFinalize"] =
-    Function::New(env, CreateExternalBufferWithFinalize);
+      Function::New(env, CreateExternalBufferWithFinalize);
   exports["createExternalBufferWithFinalizeHint"] =
-    Function::New(env, CreateExternalBufferWithFinalizeHint);
+      Function::New(env, CreateExternalBufferWithFinalizeHint);
   exports["createBufferCopy"] = Function::New(env, CreateBufferCopy);
   exports["checkBuffer"] = Function::New(env, CheckBuffer);
   exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);

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

@@ -6,7 +6,7 @@ const safeBuffer = require('safe-buffer');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   return testUtil.runGCTests([
     'Internal Buffer',
     () => {
@@ -34,8 +34,8 @@ function test(binding) {
       assert.strictEqual(0, binding.buffer.getFinalizeCount());
     },
     () => {
-        global.gc();
-        assert.strictEqual(0, binding.buffer.getFinalizeCount());
+      global.gc();
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
     },
 
     'External Buffer with finalizer',
@@ -46,24 +46,24 @@ function test(binding) {
       assert.strictEqual(0, binding.buffer.getFinalizeCount());
     },
     () => {
-        global.gc();
+      global.gc();
     },
     () => {
-        assert.strictEqual(1, binding.buffer.getFinalizeCount());
+      assert.strictEqual(1, binding.buffer.getFinalizeCount());
     },
 
     'External Buffer with finalizer hint',
     () => {
-        const test = binding.buffer.createExternalBufferWithFinalizeHint();
-        binding.buffer.checkBuffer(test);
-        assert.ok(test instanceof Buffer);
-        assert.strictEqual(0, binding.buffer.getFinalizeCount());
+      const test = binding.buffer.createExternalBufferWithFinalizeHint();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
     },
     () => {
-        global.gc();
+      global.gc();
     },
     () => {
-        assert.strictEqual(1, binding.buffer.getFinalizeCount());
-    },
+      assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    }
   ]);
 }

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

@@ -0,0 +1,27 @@
+#include <assert.h>
+#include "napi.h"
+using namespace Napi;
+
+struct TestCBInfoSetData {
+  static void Test(napi_env env, napi_callback_info info) {
+    Napi::CallbackInfo cbInfo(env, info);
+    int valuePointer = 1220202;
+    cbInfo.SetData(&valuePointer);
+
+    int* placeHolder = static_cast<int*>(cbInfo.Data());
+    assert(*(placeHolder) == valuePointer);
+    assert(placeHolder == &valuePointer);
+  }
+};
+
+void TestCallbackInfoSetData(const Napi::CallbackInfo& info) {
+  napi_callback_info cb_info = static_cast<napi_callback_info>(info);
+  TestCBInfoSetData::Test(info.Env(), cb_info);
+}
+
+Object InitCallbackInfo(Env env) {
+  Object exports = Object::New(env);
+
+  exports["testCbSetData"] = Function::New(env, TestCallbackInfoSetData);
+  return exports;
+}

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

@@ -0,0 +1,9 @@
+'use strict';
+
+const common = require('./common');
+
+module.exports = common.runTest(test);
+
+async function test (binding) {
+  binding.callbackInfo.testCbSetData();
+}

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

@@ -1,8 +1,9 @@
+#include "assert.h"
 #include "napi.h"
-
 using namespace Napi;
 
 #if (NAPI_VERSION > 2)
+
 namespace {
 
 static void RunInCallbackScope(const CallbackInfo& info) {
@@ -12,11 +13,27 @@ static void RunInCallbackScope(const CallbackInfo& info) {
   callback.Call({});
 }
 
-} // end anonymous namespace
+static void RunInCallbackScopeFromExisting(const CallbackInfo& info) {
+  Function callback = info[0].As<Function>();
+  Env env = info.Env();
+
+  AsyncContext ctx(env, "existing_callback_scope_test");
+  napi_callback_scope scope;
+  napi_open_callback_scope(env, Object::New(env), ctx, &scope);
+
+  CallbackScope existingScope(env, scope);
+  assert(existingScope.Env() == env);
+
+  callback.Call({});
+}
+
+}  // namespace
 
 Object InitCallbackScope(Env env) {
   Object exports = Object::New(env);
   exports["runInCallbackScope"] = Function::New(env, RunInCallbackScope);
+  exports["runInPreExistingCbScope"] =
+      Function::New(env, RunInCallbackScopeFromExisting);
   return exports;
 }
 #endif