koffi 0.9.0 → 0.9.3

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

@@ -0,0 +1,91 @@
+#if (NAPI_VERSION > 5)
+
+#define NAPI_EXPERIMENTAL
+#include "napi.h"
+
+#include "test_helper.h"
+
+using namespace Napi;
+
+namespace {
+
+Value IsLossless(const CallbackInfo& info) {
+  Env env = info.Env();
+
+  BigInt big = info[0].As<BigInt>();
+  bool is_signed = MaybeUnwrap(info[1].ToBoolean()).Value();
+
+  bool lossless;
+  if (is_signed) {
+    big.Int64Value(&lossless);
+  } else {
+    big.Uint64Value(&lossless);
+  }
+
+  return Boolean::New(env, lossless);
+}
+
+Value IsBigInt(const CallbackInfo& info) {
+  Env env = info.Env();
+
+  BigInt big = info[0].As<BigInt>();
+
+  return Boolean::New(env, big.IsBigInt());
+}
+
+Value TestInt64(const CallbackInfo& info) {
+  bool lossless;
+  int64_t input = info[0].As<BigInt>().Int64Value(&lossless);
+
+  return BigInt::New(info.Env(), input);
+}
+
+Value TestUint64(const CallbackInfo& info) {
+  bool lossless;
+  uint64_t input = info[0].As<BigInt>().Uint64Value(&lossless);
+
+  return BigInt::New(info.Env(), input);
+}
+
+Value TestWords(const CallbackInfo& info) {
+  BigInt big = info[0].As<BigInt>();
+
+  size_t expected_word_count = big.WordCount();
+
+  int sign_bit;
+  size_t word_count = 10;
+  uint64_t words[10] = {0};
+
+  big.ToWords(&sign_bit, &word_count, words);
+
+  if (word_count != expected_word_count) {
+    Error::New(info.Env(), "word count did not match").ThrowAsJavaScriptException();
+    return BigInt();
+  }
+
+  return BigInt::New(info.Env(), sign_bit, word_count, words);
+}
+
+Value TestTooBigBigInt(const CallbackInfo& info) {
+  int sign_bit = 0;
+  size_t word_count = SIZE_MAX;
+  uint64_t words[10] = {0};
+
+  return BigInt::New(info.Env(), sign_bit, word_count, words);
+}
+
+}  // anonymous namespace
+
+Object InitBigInt(Env env) {
+  Object exports = Object::New(env);
+  exports["IsLossless"] = Function::New(env, IsLossless);
+  exports["IsBigInt"] = Function::New(env, IsBigInt);
+  exports["TestInt64"] = Function::New(env, TestInt64);
+  exports["TestUint64"] = Function::New(env, TestUint64);
+  exports["TestWords"] = Function::New(env, TestWords);
+  exports["TestTooBigBigInt"] = Function::New(env, TestTooBigBigInt);
+
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,53 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test (binding) {
+  const {
+    TestInt64,
+    TestUint64,
+    TestWords,
+    IsLossless,
+    IsBigInt,
+    TestTooBigBigInt
+  } = binding.bigint;
+
+  [
+    0n,
+    -0n,
+    1n,
+    -1n,
+    100n,
+    2121n,
+    -1233n,
+    986583n,
+    -976675n,
+    98765432213456789876546896323445679887645323232436587988766545658n,
+    -4350987086545760976737453646576078997096876957864353245245769809n
+  ].forEach((num) => {
+    if (num > -(2n ** 63n) && num < 2n ** 63n) {
+      assert.strictEqual(TestInt64(num), num);
+      assert.strictEqual(IsLossless(num, true), true);
+    } else {
+      assert.strictEqual(IsLossless(num, true), false);
+    }
+
+    if (num >= 0 && num < 2n ** 64n) {
+      assert.strictEqual(TestUint64(num), num);
+      assert.strictEqual(IsLossless(num, false), true);
+    } else {
+      assert.strictEqual(IsLossless(num, false), false);
+    }
+
+    assert.strictEqual(IsBigInt(num), true);
+
+    assert.strictEqual(num, TestWords(num));
+  });
+
+  assert.throws(TestTooBigBigInt, {
+    name: /^(RangeError|Error)$/,
+    message: /^(Maximum BigInt size exceeded|Invalid argument)$/
+  });
+}

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

@@ -0,0 +1,12 @@
+#include "napi.h"
+
+using namespace Napi;
+
+Object InitError(Env env);
+
+Object Init(Env env, Object exports) {
+  exports.Set("error", InitError(env));
+  return exports;
+}
+
+NODE_API_MODULE(addon, Init)

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

@@ -0,0 +1,171 @@
+#include "napi.h"
+
+using namespace Napi;
+
+#if (NAPI_VERSION > 5)
+Object InitAddon(Env env);
+Object InitAddonData(Env env);
+#endif
+Object InitArrayBuffer(Env env);
+Object InitAsyncContext(Env env);
+#if (NAPI_VERSION > 3)
+Object InitAsyncProgressQueueWorker(Env env);
+Object InitAsyncProgressWorker(Env env);
+#endif
+Object InitAsyncWorker(Env env);
+Object InitPersistentAsyncWorker(Env env);
+Object InitBasicTypesArray(Env env);
+Object InitBasicTypesBoolean(Env env);
+Object InitBasicTypesNumber(Env env);
+Object InitBasicTypesValue(Env env);
+#if (NAPI_VERSION > 5)
+Object InitBigInt(Env env);
+#endif
+Object InitBuffer(Env env);
+#if (NAPI_VERSION > 2)
+Object InitCallbackScope(Env env);
+#endif
+#if (NAPI_VERSION > 4)
+Object InitDate(Env env);
+#endif
+Object InitDataView(Env env);
+Object InitDataViewReadWrite(Env env);
+Object InitEnvCleanup(Env env);
+Object InitErrorHandlingPrim(Env env);
+Object InitError(Env env);
+Object InitExternal(Env env);
+Object InitFunction(Env env);
+Object InitFunctionReference(Env env);
+Object InitHandleScope(Env env);
+Object InitMovableCallbacks(Env env);
+Object InitMemoryManagement(Env env);
+Object InitName(Env env);
+Object InitObject(Env env);
+#ifndef NODE_ADDON_API_DISABLE_DEPRECATED
+Object InitObjectDeprecated(Env env);
+#endif // !NODE_ADDON_API_DISABLE_DEPRECATED
+Object InitPromise(Env env);
+Object InitRunScript(Env env);
+#if (NAPI_VERSION > 3)
+Object InitThreadSafeFunctionCtx(Env env);
+Object InitThreadSafeFunctionExistingTsfn(Env env);
+Object InitThreadSafeFunctionPtr(Env env);
+Object InitThreadSafeFunctionSum(Env env);
+Object InitThreadSafeFunctionUnref(Env env);
+Object InitThreadSafeFunction(Env env);
+Object InitTypedThreadSafeFunctionCtx(Env env);
+Object InitTypedThreadSafeFunctionExistingTsfn(Env env);
+Object InitTypedThreadSafeFunctionPtr(Env env);
+Object InitTypedThreadSafeFunctionSum(Env env);
+Object InitTypedThreadSafeFunctionUnref(Env env);
+Object InitTypedThreadSafeFunction(Env env);
+#endif
+Object InitSymbol(Env env);
+Object InitTypedArray(Env env);
+Object InitGlobalObject(Env env);
+Object InitObjectWrap(Env env);
+Object InitObjectWrapConstructorException(Env env);
+Object InitObjectWrapRemoveWrap(Env env);
+Object InitObjectWrapMultipleInheritance(Env env);
+Object InitObjectReference(Env env);
+Object InitReference(Env env);
+Object InitVersionManagement(Env env);
+Object InitThunkingManual(Env env);
+#if (NAPI_VERSION > 7)
+Object InitObjectFreezeSeal(Env env);
+#endif
+
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+Object InitMaybeCheck(Env env);
+#endif
+
+Object Init(Env env, Object exports) {
+#if (NAPI_VERSION > 5)
+  exports.Set("addon", InitAddon(env));
+  exports.Set("addon_data", InitAddonData(env));
+#endif
+  exports.Set("arraybuffer", InitArrayBuffer(env));
+  exports.Set("asynccontext", InitAsyncContext(env));
+#if (NAPI_VERSION > 3)
+  exports.Set("asyncprogressqueueworker", InitAsyncProgressQueueWorker(env));
+  exports.Set("asyncprogressworker", InitAsyncProgressWorker(env));
+#endif
+  exports.Set("globalObject", InitGlobalObject(env));
+  exports.Set("asyncworker", InitAsyncWorker(env));
+  exports.Set("persistentasyncworker", InitPersistentAsyncWorker(env));
+  exports.Set("basic_types_array", InitBasicTypesArray(env));
+  exports.Set("basic_types_boolean", InitBasicTypesBoolean(env));
+  exports.Set("basic_types_number", InitBasicTypesNumber(env));
+  exports.Set("basic_types_value", InitBasicTypesValue(env));
+#if (NAPI_VERSION > 5)
+  exports.Set("bigint", InitBigInt(env));
+#endif
+#if (NAPI_VERSION > 4)
+  exports.Set("date", InitDate(env));
+#endif
+  exports.Set("buffer", InitBuffer(env));
+#if (NAPI_VERSION > 2)
+  exports.Set("callbackscope", InitCallbackScope(env));
+#endif
+  exports.Set("dataview", InitDataView(env));
+  exports.Set("dataview_read_write", InitDataView(env));
+  exports.Set("dataview_read_write", InitDataViewReadWrite(env));
+#if (NAPI_VERSION > 2)
+  exports.Set("env_cleanup", InitEnvCleanup(env));
+#endif
+  exports.Set("error", InitError(env));
+  exports.Set("errorHandlingPrim", InitErrorHandlingPrim(env));
+  exports.Set("external", InitExternal(env));
+  exports.Set("function", InitFunction(env));
+  exports.Set("functionreference", InitFunctionReference(env));
+  exports.Set("name", InitName(env));
+  exports.Set("handlescope", InitHandleScope(env));
+  exports.Set("movable_callbacks", InitMovableCallbacks(env));
+  exports.Set("memory_management", InitMemoryManagement(env));
+  exports.Set("object", InitObject(env));
+#ifndef NODE_ADDON_API_DISABLE_DEPRECATED
+  exports.Set("object_deprecated", InitObjectDeprecated(env));
+#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_ptr", InitThreadSafeFunctionPtr(env));
+  exports.Set("threadsafe_function_sum", InitThreadSafeFunctionSum(env));
+  exports.Set("threadsafe_function_unref", InitThreadSafeFunctionUnref(env));
+  exports.Set("threadsafe_function", InitThreadSafeFunction(env));
+  exports.Set("typed_threadsafe_function_ctx",
+              InitTypedThreadSafeFunctionCtx(env));
+  exports.Set("typed_threadsafe_function_existing_tsfn",
+              InitTypedThreadSafeFunctionExistingTsfn(env));
+  exports.Set("typed_threadsafe_function_ptr",
+              InitTypedThreadSafeFunctionPtr(env));
+  exports.Set("typed_threadsafe_function_sum",
+              InitTypedThreadSafeFunctionSum(env));
+  exports.Set("typed_threadsafe_function_unref",
+              InitTypedThreadSafeFunctionUnref(env));
+  exports.Set("typed_threadsafe_function", InitTypedThreadSafeFunction(env));
+#endif
+  exports.Set("typedarray", InitTypedArray(env));
+  exports.Set("objectwrap", InitObjectWrap(env));
+  exports.Set("objectwrapConstructorException",
+      InitObjectWrapConstructorException(env));
+  exports.Set("objectwrap_removewrap", InitObjectWrapRemoveWrap(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));
+#endif
+
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  exports.Set("maybe_check", InitMaybeCheck(env));
+#endif
+  return exports;
+}
+
+NODE_API_MODULE(addon, Init)

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

@@ -0,0 +1,117 @@
+{
+  'target_defaults': {
+    'includes': ['../common.gypi'],
+    'include_dirs': ['./common'],
+    'variables': {
+      'build_sources': [
+        'addon.cc',
+        'addon_data.cc',
+        'array_buffer.cc',
+        'async_context.cc',
+        'async_progress_queue_worker.cc',
+        'async_progress_worker.cc',
+        'async_worker.cc',
+        'async_worker_persistent.cc',
+        'basic_types/array.cc',
+        'basic_types/boolean.cc',
+        'basic_types/number.cc',
+        'basic_types/value.cc',
+        'bigint.cc',
+        'date.cc',
+        'binding.cc',
+        'buffer.cc',
+        'callbackscope.cc',
+        'dataview/dataview.cc',
+        'dataview/dataview_read_write.cc',
+        'env_cleanup.cc',
+        'error.cc',
+        'error_handling_for_primitives.cc',
+        'external.cc',
+        'function.cc',
+        'function_reference.cc',
+        'handlescope.cc',
+        'maybe/check.cc',
+        'movable_callbacks.cc',
+        'memory_management.cc',
+        'name.cc',
+        'globalObject/global_object_delete_property.cc',
+        'globalObject/global_object_has_own_property.cc',
+        'globalObject/global_object_set_property.cc',
+        'globalObject/global_object_get_property.cc',
+        'globalObject/global_object.cc',
+        'object/delete_property.cc',
+        'object/finalizer.cc',
+        'object/get_property.cc',
+        'object/has_own_property.cc',
+        'object/has_property.cc',
+        'object/object.cc',
+        'object/object_freeze_seal.cc',
+        'object/set_property.cc',
+        'object/subscript_operator.cc',
+        'promise.cc',
+        'run_script.cc',
+        "symbol.cc",
+        'threadsafe_function/threadsafe_function_ctx.cc',
+        'threadsafe_function/threadsafe_function_existing_tsfn.cc',
+        'threadsafe_function/threadsafe_function_ptr.cc',
+        'threadsafe_function/threadsafe_function_sum.cc',
+        'threadsafe_function/threadsafe_function_unref.cc',
+        'threadsafe_function/threadsafe_function.cc',
+        'typed_threadsafe_function/typed_threadsafe_function_ctx.cc',
+        'typed_threadsafe_function/typed_threadsafe_function_existing_tsfn.cc',
+        'typed_threadsafe_function/typed_threadsafe_function_ptr.cc',
+        'typed_threadsafe_function/typed_threadsafe_function_sum.cc',
+        'typed_threadsafe_function/typed_threadsafe_function_unref.cc',
+        'typed_threadsafe_function/typed_threadsafe_function.cc',
+        'typedarray.cc',
+        'objectwrap.cc',
+        'objectwrap_constructor_exception.cc',
+        'objectwrap_removewrap.cc',
+        'objectwrap_multiple_inheritance.cc',
+        'object_reference.cc',
+        'reference.cc',
+        'version_management.cc',
+        'thunking_manual.cc',
+      ],
+      'build_sources_swallowexcept': [
+        'binding-swallowexcept.cc',
+        'error.cc',
+      ],
+      'conditions': [
+        ['disable_deprecated!="true"', {
+          'build_sources': ['object/object_deprecated.cc']
+        }]
+      ]
+    },
+  },
+  'targets': [
+    {
+      'target_name': 'binding',
+      'includes': ['../except.gypi'],
+      'sources': ['>@(build_sources)']
+    },
+    {
+      'target_name': 'binding_noexcept',
+      'includes': ['../noexcept.gypi'],
+      'sources': ['>@(build_sources)']
+    },
+    {
+      'target_name': 'binding_noexcept_maybe',
+      'includes': ['../noexcept.gypi'],
+      'sources': ['>@(build_sources)'],
+      'defines': ['NODE_ADDON_API_ENABLE_MAYBE']
+    },
+    {
+      'target_name': 'binding_swallowexcept',
+      'includes': ['../except.gypi'],
+      'sources': [ '>@(build_sources_swallowexcept)'],
+      'defines': ['NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS']
+    },
+    {
+      'target_name': 'binding_swallowexcept_noexcept',
+      'includes': ['../noexcept.gypi'],
+      'sources': ['>@(build_sources_swallowexcept)'],
+      'defines': ['NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS']
+    },
+  ],
+}

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

@@ -0,0 +1,183 @@
+#include "napi.h"
+
+using namespace Napi;
+
+namespace {
+
+const size_t testLength = 4;
+uint16_t testData[testLength];
+int finalizeCount = 0;
+
+template <typename T>
+void InitData(T* data, size_t length) {
+  for (size_t i = 0; i < length; i++) {
+    data[i] = static_cast<T>(i);
+  }
+}
+
+template <typename T>
+bool VerifyData(T* data, size_t length) {
+  for (size_t i = 0; i < length; i++) {
+    if (data[i] != static_cast<T>(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+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();
+    return Value();
+  }
+
+  InitData(buffer.Data(), testLength);
+  return buffer;
+}
+
+Value CreateExternalBuffer(const CallbackInfo& info) {
+  finalizeCount = 0;
+
+  Buffer<uint16_t> buffer = Buffer<uint16_t>::New(
+    info.Env(),
+    testData,
+    testLength);
+
+  if (buffer.Length() != testLength) {
+    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  if (buffer.Data() != testData) {
+    Error::New(info.Env(), "Incorrect buffer data.").ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  InitData(testData, testLength);
+  return buffer;
+}
+
+Value CreateExternalBufferWithFinalize(const CallbackInfo& info) {
+  finalizeCount = 0;
+
+  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++;
+    });
+
+  if (buffer.Length() != testLength) {
+    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  if (buffer.Data() != data) {
+    Error::New(info.Env(), "Incorrect buffer data.").ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  InitData(data, testLength);
+  return buffer;
+}
+
+Value CreateExternalBufferWithFinalizeHint(const CallbackInfo& info) {
+  finalizeCount = 0;
+
+  uint16_t* data = new uint16_t[testLength];
+
+  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);
+
+  if (buffer.Length() != testLength) {
+    Error::New(info.Env(), "Incorrect buffer length.").ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  if (buffer.Data() != data) {
+    Error::New(info.Env(), "Incorrect buffer data.").ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  InitData(data, testLength);
+  return buffer;
+}
+
+Value CreateBufferCopy(const CallbackInfo& info) {
+  InitData(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();
+    return Value();
+  }
+
+  if (buffer.Data() == testData) {
+    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();
+    return Value();
+  }
+
+  return buffer;
+}
+
+void CheckBuffer(const CallbackInfo& info) {
+  if (!info[0].IsBuffer()) {
+    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();
+    return;
+  }
+
+  if (!VerifyData(buffer.Data(), testLength)) {
+    Error::New(info.Env(), "Incorrect buffer data.").ThrowAsJavaScriptException();
+    return;
+  }
+}
+
+Value GetFinalizeCount(const CallbackInfo& info) {
+   return Number::New(info.Env(), finalizeCount);
+}
+
+} // end anonymous namespace
+
+Object InitBuffer(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createBuffer"] = Function::New(env, CreateBuffer);
+  exports["createExternalBuffer"] = Function::New(env, CreateExternalBuffer);
+  exports["createExternalBufferWithFinalize"] =
+    Function::New(env, CreateExternalBufferWithFinalize);
+  exports["createExternalBufferWithFinalizeHint"] =
+    Function::New(env, CreateExternalBufferWithFinalizeHint);
+  exports["createBufferCopy"] = Function::New(env, CreateBufferCopy);
+  exports["checkBuffer"] = Function::New(env, CheckBuffer);
+  exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);
+
+  return exports;
+}

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

@@ -0,0 +1,69 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+const safeBuffer = require('safe-buffer');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  return testUtil.runGCTests([
+    'Internal Buffer',
+    () => {
+      const test = binding.buffer.createBuffer();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+
+      const test2 = safeBuffer.Buffer.alloc(test.length);
+      test.copy(test2);
+      binding.buffer.checkBuffer(test2);
+    },
+
+    'Buffer copy',
+    () => {
+      const test = binding.buffer.createBufferCopy();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+    },
+
+    'External Buffer',
+    () => {
+      const test = binding.buffer.createExternalBuffer();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+        global.gc();
+        assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+
+    'External Buffer with finalizer',
+    () => {
+      const test = binding.buffer.createExternalBufferWithFinalize();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+        global.gc();
+    },
+    () => {
+        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());
+    },
+    () => {
+        global.gc();
+    },
+    () => {
+        assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+  ]);
+}