koffi 0.9.4 → 0.9.5

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

@@ -1,108 +1,108 @@
-#include "napi.h"
-
-using namespace Napi;
-
-const char* testValueUtf8 = "123456789";
-const char16_t* testValueUtf16 = NAPI_WIDE_TEXT("123456789");
-
-Value EchoString(const CallbackInfo& info) {
-  String value = info[0].As<String>();
-  String encoding = info[1].As<String>();
-
-  if (encoding.Utf8Value() == "utf8") {
-    return String::New(info.Env(), value.Utf8Value().c_str());
-  } else if (encoding.Utf8Value() == "utf16") {
-    return String::New(info.Env(), value.Utf16Value().c_str());
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CreateString(const CallbackInfo& info) {
-  String encoding = info[0].As<String>();
-  Number length = info[1].As<Number>();
-
-  if (encoding.Utf8Value() == "utf8") {
-    if (length.IsUndefined()) {
-      return String::New(info.Env(), testValueUtf8);
-    } else {
-      return String::New(info.Env(), testValueUtf8, length.Uint32Value());
-    }
-  } else if (encoding.Utf8Value() == "utf16") {
-    if (length.IsUndefined()) {
-      return String::New(info.Env(), testValueUtf16);
-    } else {
-      return String::New(info.Env(), testValueUtf16, length.Uint32Value());
-    }
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CheckString(const CallbackInfo& info) {
-  String value = info[0].As<String>();
-  String encoding = info[1].As<String>();
-  Number length = info[2].As<Number>();
-
-  if (encoding.Utf8Value() == "utf8") {
-    std::string testValue = testValueUtf8;
-    if (!length.IsUndefined()) {
-      testValue = testValue.substr(0, length.Uint32Value());
-    }
-
-    std::string stringValue = value;
-    return Boolean::New(info.Env(), stringValue == testValue);
-  } else if (encoding.Utf8Value() == "utf16") {
-    std::u16string testValue = testValueUtf16;
-    if (!length.IsUndefined()) {
-      testValue = testValue.substr(0, length.Uint32Value());
-    }
-
-    std::u16string stringValue = value;
-    return Boolean::New(info.Env(), stringValue == testValue);
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CreateSymbol(const CallbackInfo& info) {
-  String description = info[0].As<String>();
-
-  if (!description.IsUndefined()) {
-    return Symbol::New(info.Env(), description);
-  } else {
-    return Symbol::New(info.Env());
-  }
-}
-
-Value CheckSymbol(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].Type() == napi_symbol);
-}
-
-void NullStringShouldThrow(const CallbackInfo& info) {
-  const char* nullStr = nullptr;
-  String::New(info.Env(), nullStr);
-}
-
-void NullString16ShouldThrow(const CallbackInfo& info) {
-  const char16_t* nullStr = nullptr;
-  String::New(info.Env(), nullStr);
-}
-
-Object InitName(Env env) {
-  Object exports = Object::New(env);
-
-  exports["echoString"] = Function::New(env, EchoString);
-  exports["createString"] = Function::New(env, CreateString);
-  exports["nullStringShouldThrow"] = Function::New(env, NullStringShouldThrow);
-  exports["nullString16ShouldThrow"] =
-      Function::New(env, NullString16ShouldThrow);
-  exports["checkString"] = Function::New(env, CheckString);
-  exports["createSymbol"] = Function::New(env, CreateSymbol);
-  exports["checkSymbol"] = Function::New(env, CheckSymbol);
-
-  return exports;
-}
+#include "napi.h"
+
+using namespace Napi;
+
+const char* testValueUtf8 = "123456789";
+const char16_t* testValueUtf16 = NAPI_WIDE_TEXT("123456789");
+
+Value EchoString(const CallbackInfo& info) {
+  String value = info[0].As<String>();
+  String encoding = info[1].As<String>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    return String::New(info.Env(), value.Utf8Value().c_str());
+  } else if (encoding.Utf8Value() == "utf16") {
+    return String::New(info.Env(), value.Utf16Value().c_str());
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CreateString(const CallbackInfo& info) {
+  String encoding = info[0].As<String>();
+  Number length = info[1].As<Number>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    if (length.IsUndefined()) {
+      return String::New(info.Env(), testValueUtf8);
+    } else {
+      return String::New(info.Env(), testValueUtf8, length.Uint32Value());
+    }
+  } else if (encoding.Utf8Value() == "utf16") {
+    if (length.IsUndefined()) {
+      return String::New(info.Env(), testValueUtf16);
+    } else {
+      return String::New(info.Env(), testValueUtf16, length.Uint32Value());
+    }
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CheckString(const CallbackInfo& info) {
+  String value = info[0].As<String>();
+  String encoding = info[1].As<String>();
+  Number length = info[2].As<Number>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    std::string testValue = testValueUtf8;
+    if (!length.IsUndefined()) {
+      testValue = testValue.substr(0, length.Uint32Value());
+    }
+
+    std::string stringValue = value;
+    return Boolean::New(info.Env(), stringValue == testValue);
+  } else if (encoding.Utf8Value() == "utf16") {
+    std::u16string testValue = testValueUtf16;
+    if (!length.IsUndefined()) {
+      testValue = testValue.substr(0, length.Uint32Value());
+    }
+
+    std::u16string stringValue = value;
+    return Boolean::New(info.Env(), stringValue == testValue);
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CreateSymbol(const CallbackInfo& info) {
+  String description = info[0].As<String>();
+
+  if (!description.IsUndefined()) {
+    return Symbol::New(info.Env(), description);
+  } else {
+    return Symbol::New(info.Env());
+  }
+}
+
+Value CheckSymbol(const CallbackInfo& info) {
+  return Boolean::New(info.Env(), info[0].Type() == napi_symbol);
+}
+
+void NullStringShouldThrow(const CallbackInfo& info) {
+  const char* nullStr = nullptr;
+  String::New(info.Env(), nullStr);
+}
+
+void NullString16ShouldThrow(const CallbackInfo& info) {
+  const char16_t* nullStr = nullptr;
+  String::New(info.Env(), nullStr);
+}
+
+Object InitName(Env env) {
+  Object exports = Object::New(env);
+
+  exports["echoString"] = Function::New(env, EchoString);
+  exports["createString"] = Function::New(env, CreateString);
+  exports["nullStringShouldThrow"] = Function::New(env, NullStringShouldThrow);
+  exports["nullString16ShouldThrow"] =
+      Function::New(env, NullString16ShouldThrow);
+  exports["checkString"] = Function::New(env, CheckString);
+  exports["createSymbol"] = Function::New(env, CreateSymbol);
+  exports["checkSymbol"] = Function::New(env, CheckSymbol);
+
+  return exports;
+}

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

@@ -1,59 +1,59 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  const expected = '123456789';
-
-
-  assert.throws(binding.name.nullStringShouldThrow, {
-    name: 'Error',
-    message: 'Error in native callback',
-  });
-  assert.ok(binding.name.checkString(expected, 'utf8'));
-  assert.ok(binding.name.checkString(expected, 'utf16'));
-  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf8', 3));
-  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf16', 3));
-
-  const str1 = binding.name.createString('utf8');
-  assert.strictEqual(str1, expected);
-  assert.ok(binding.name.checkString(str1, 'utf8'));
-  assert.ok(binding.name.checkString(str1, 'utf16'));
-
-  const substr1 = binding.name.createString('utf8', 3);
-  assert.strictEqual(substr1, expected.substr(0, 3));
-  assert.ok(binding.name.checkString(substr1, 'utf8', 3));
-  assert.ok(binding.name.checkString(substr1, 'utf16', 3));
-
-  const str2 = binding.name.createString('utf16');
-  assert.strictEqual(str1, expected);
-  assert.ok(binding.name.checkString(str2, 'utf8'));
-  assert.ok(binding.name.checkString(str2, 'utf16'));
-
-  const substr2 = binding.name.createString('utf16', 3);
-  assert.strictEqual(substr1, expected.substr(0, 3));
-  assert.ok(binding.name.checkString(substr2, 'utf8', 3));
-  assert.ok(binding.name.checkString(substr2, 'utf16', 3));
-
-  assert.ok(binding.name.checkSymbol(Symbol()));
-  assert.ok(binding.name.checkSymbol(Symbol('test')));
-
-  const sym1 = binding.name.createSymbol();
-  assert.strictEqual(typeof sym1, 'symbol');
-  assert.ok(binding.name.checkSymbol(sym1));
-
-  const sym2 = binding.name.createSymbol('test');
-  assert.strictEqual(typeof sym2, 'symbol');
-  assert.ok(binding.name.checkSymbol(sym1));
-
-  // Check for off-by-one errors which might only appear for strings of certain sizes,
-  // due to how std::string increments its capacity in chunks.
-  const longString = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-  for (let i = 10; i <= longString.length; i++) {
-    const str = longString.substr(0, i);
-    assert.strictEqual(binding.name.echoString(str, 'utf8'), str);
-    assert.strictEqual(binding.name.echoString(str, 'utf16'), str);
-  }
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  const expected = '123456789';
+
+
+  assert.throws(binding.name.nullStringShouldThrow, {
+    name: 'Error',
+    message: 'Error in native callback',
+  });
+  assert.ok(binding.name.checkString(expected, 'utf8'));
+  assert.ok(binding.name.checkString(expected, 'utf16'));
+  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf8', 3));
+  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf16', 3));
+
+  const str1 = binding.name.createString('utf8');
+  assert.strictEqual(str1, expected);
+  assert.ok(binding.name.checkString(str1, 'utf8'));
+  assert.ok(binding.name.checkString(str1, 'utf16'));
+
+  const substr1 = binding.name.createString('utf8', 3);
+  assert.strictEqual(substr1, expected.substr(0, 3));
+  assert.ok(binding.name.checkString(substr1, 'utf8', 3));
+  assert.ok(binding.name.checkString(substr1, 'utf16', 3));
+
+  const str2 = binding.name.createString('utf16');
+  assert.strictEqual(str1, expected);
+  assert.ok(binding.name.checkString(str2, 'utf8'));
+  assert.ok(binding.name.checkString(str2, 'utf16'));
+
+  const substr2 = binding.name.createString('utf16', 3);
+  assert.strictEqual(substr1, expected.substr(0, 3));
+  assert.ok(binding.name.checkString(substr2, 'utf8', 3));
+  assert.ok(binding.name.checkString(substr2, 'utf16', 3));
+
+  assert.ok(binding.name.checkSymbol(Symbol()));
+  assert.ok(binding.name.checkSymbol(Symbol('test')));
+
+  const sym1 = binding.name.createSymbol();
+  assert.strictEqual(typeof sym1, 'symbol');
+  assert.ok(binding.name.checkSymbol(sym1));
+
+  const sym2 = binding.name.createSymbol('test');
+  assert.strictEqual(typeof sym2, 'symbol');
+  assert.ok(binding.name.checkSymbol(sym1));
+
+  // Check for off-by-one errors which might only appear for strings of certain sizes,
+  // due to how std::string increments its capacity in chunks.
+  const longString = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+  for (let i = 10; i <= longString.length; i++) {
+    const str = longString.substr(0, i);
+    assert.strictEqual(binding.name.echoString(str, 'utf8'), str);
+    assert.strictEqual(binding.name.echoString(str, 'utf16'), str);
+  }
+}

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

@@ -1,14 +1,14 @@
-// Makes sure that child processes are spawned appropriately.
-exports.spawnSync = function(command, args, options) {
-  if (require('../index').needsFlag) {
-    args.splice(0, 0, '--napi-modules');
-  }
-  return require('child_process').spawnSync(command, args, options);
-};
-
-exports.spawn = function(command, args, options) {
-  if (require('../index').needsFlag) {
-    args.splice(0, 0, '--napi-modules');
-  }
-  return require('child_process').spawn(command, args, options);
-};
+// Makes sure that child processes are spawned appropriately.
+exports.spawnSync = function(command, args, options) {
+  if (require('../index').needsFlag) {
+    args.splice(0, 0, '--napi-modules');
+  }
+  return require('child_process').spawnSync(command, args, options);
+};
+
+exports.spawn = function(command, args, options) {
+  if (require('../index').needsFlag) {
+    args.splice(0, 0, '--napi-modules');
+  }
+  return require('child_process').spawn(command, args, options);
+};

package/vendor/node-addon-api/test/object/delete_property.cc

@@ -1,38 +1,38 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-Value DeletePropertyWithUint32(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Number key = info[1].As<Number>();
-  return Boolean::New(info.Env(), MaybeUnwrap(obj.Delete(key.Uint32Value())));
-}
-
-Value DeletePropertyWithNapiValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Name key = info[1].As<Name>();
-  return Boolean::New(
-      info.Env(),
-      MaybeUnwrapOr(obj.Delete(static_cast<napi_value>(key)), false));
-}
-
-Value DeletePropertyWithNapiWrapperValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Name key = info[1].As<Name>();
-  return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Delete(key), false));
-}
-
-Value DeletePropertyWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  String jsKey = info[1].As<String>();
-  return Boolean::New(
-      info.Env(), MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value().c_str()), false));
-}
-
-Value DeletePropertyWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  String jsKey = info[1].As<String>();
-  return Boolean::New(info.Env(),
-                      MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value()), false));
-}
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value DeletePropertyWithUint32(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Number key = info[1].As<Number>();
+  return Boolean::New(info.Env(), MaybeUnwrap(obj.Delete(key.Uint32Value())));
+}
+
+Value DeletePropertyWithNapiValue(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Name key = info[1].As<Name>();
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(obj.Delete(static_cast<napi_value>(key)), false));
+}
+
+Value DeletePropertyWithNapiWrapperValue(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Name key = info[1].As<Name>();
+  return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Delete(key), false));
+}
+
+Value DeletePropertyWithCStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  return Boolean::New(
+      info.Env(), MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value().c_str()), false));
+}
+
+Value DeletePropertyWithCppStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  return Boolean::New(info.Env(),
+                      MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value()), false));
+}

package/vendor/node-addon-api/test/object/delete_property.js

@@ -1,41 +1,41 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  function testDeleteProperty(nativeDeleteProperty) {
-    const obj = { one: 1, two: 2 };
-    Object.defineProperty(obj, "three", {configurable: false, value: 3});
-    assert.strictEqual(nativeDeleteProperty(obj, 'one'), true);
-    assert.strictEqual(nativeDeleteProperty(obj, 'missing'), true);
-
-    /* Returns true for all cases except when the property is an own non-
-       configurable property, in which case, false is returned in non-strict mode. */
-    assert.strictEqual(nativeDeleteProperty(obj, 'three'), false);
-    assert.deepStrictEqual(obj, { two: 2 });
-  }
-
-  function testShouldThrowErrorIfKeyIsInvalid(nativeDeleteProperty) {
-    assert.throws(() => {
-      nativeDeleteProperty(undefined, 'test');
-    }, /Cannot convert undefined or null to object/);
-  }
-
-  const testObj = { 15 : 42 , three: 3};
-
-  binding.object.deletePropertyWithUint32(testObj,15);
-
-  assert.strictEqual(testObj.hasOwnProperty(15),false);
-
-  testDeleteProperty(binding.object.deletePropertyWithNapiValue);
-  testDeleteProperty(binding.object.deletePropertyWithNapiWrapperValue);
-  testDeleteProperty(binding.object.deletePropertyWithCStyleString);
-  testDeleteProperty(binding.object.deletePropertyWithCppStyleString);
-
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithNapiValue);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithNapiWrapperValue);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithCStyleString);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithCppStyleString);
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function testDeleteProperty(nativeDeleteProperty) {
+    const obj = { one: 1, two: 2 };
+    Object.defineProperty(obj, "three", {configurable: false, value: 3});
+    assert.strictEqual(nativeDeleteProperty(obj, 'one'), true);
+    assert.strictEqual(nativeDeleteProperty(obj, 'missing'), true);
+
+    /* Returns true for all cases except when the property is an own non-
+       configurable property, in which case, false is returned in non-strict mode. */
+    assert.strictEqual(nativeDeleteProperty(obj, 'three'), false);
+    assert.deepStrictEqual(obj, { two: 2 });
+  }
+
+  function testShouldThrowErrorIfKeyIsInvalid(nativeDeleteProperty) {
+    assert.throws(() => {
+      nativeDeleteProperty(undefined, 'test');
+    }, /Cannot convert undefined or null to object/);
+  }
+
+  const testObj = { 15 : 42 , three: 3};
+
+  binding.object.deletePropertyWithUint32(testObj,15);
+
+  assert.strictEqual(testObj.hasOwnProperty(15),false);
+
+  testDeleteProperty(binding.object.deletePropertyWithNapiValue);
+  testDeleteProperty(binding.object.deletePropertyWithNapiWrapperValue);
+  testDeleteProperty(binding.object.deletePropertyWithCStyleString);
+  testDeleteProperty(binding.object.deletePropertyWithCppStyleString);
+
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithNapiValue);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithNapiWrapperValue);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithCStyleString);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithCppStyleString);
+}

package/vendor/node-addon-api/test/object/finalizer.cc

@@ -1,29 +1,29 @@
-#include "napi.h"
-
-using namespace Napi;
-
-static int dummy;
-
-Value AddFinalizer(const CallbackInfo& info) {
-  ObjectReference* ref = new ObjectReference;
-  *ref = Persistent(Object::New(info.Env()));
-  info[0]
-    .As<Object>()
-    .AddFinalizer([](Napi::Env /*env*/, ObjectReference* ref) {
-      ref->Set("finalizerCalled", true);
-      delete ref;
-    }, ref);
-  return ref->Value();
-}
-
-Value AddFinalizerWithHint(const CallbackInfo& info) {
-  ObjectReference* ref = new ObjectReference;
-  *ref = Persistent(Object::New(info.Env()));
-  info[0]
-    .As<Object>()
-    .AddFinalizer([](Napi::Env /*env*/, ObjectReference* ref, int* dummy_p) {
-      ref->Set("finalizerCalledWithCorrectHint", dummy_p == &dummy);
-      delete ref;
-    }, ref, &dummy);
-  return ref->Value();
-}
+#include "napi.h"
+
+using namespace Napi;
+
+static int dummy;
+
+Value AddFinalizer(const CallbackInfo& info) {
+  ObjectReference* ref = new ObjectReference;
+  *ref = Persistent(Object::New(info.Env()));
+  info[0]
+    .As<Object>()
+    .AddFinalizer([](Napi::Env /*env*/, ObjectReference* ref) {
+      ref->Set("finalizerCalled", true);
+      delete ref;
+    }, ref);
+  return ref->Value();
+}
+
+Value AddFinalizerWithHint(const CallbackInfo& info) {
+  ObjectReference* ref = new ObjectReference;
+  *ref = Persistent(Object::New(info.Env()));
+  info[0]
+    .As<Object>()
+    .AddFinalizer([](Napi::Env /*env*/, ObjectReference* ref, int* dummy_p) {
+      ref->Set("finalizerCalledWithCorrectHint", dummy_p == &dummy);
+      delete ref;
+    }, ref, &dummy);
+  return ref->Value();
+}

package/vendor/node-addon-api/test/object/finalizer.js

@@ -1,28 +1,28 @@
-'use strict';
-
-const assert = require('assert');
-const testUtil = require('../testUtil');
-
-module.exports = require('../common').runTest(test);
-
-function createWeakRef(binding, bindingToTest) {
-  return binding.object[bindingToTest]({});
-}
-
-function test(binding) {
-  let obj1;
-  let obj2;
-  return testUtil.runGCTests([
-    'addFinalizer',
-    () => {
-      obj1 = createWeakRef(binding, 'addFinalizer');
-    },
-    () => assert.deepStrictEqual(obj1, { finalizerCalled: true }),
-
-    'addFinalizerWithHint',
-    () => {
-      obj2 = createWeakRef(binding, 'addFinalizerWithHint');
-    },
-    () => assert.deepStrictEqual(obj2, { finalizerCalledWithCorrectHint: true })
-  ]);
-}
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('../testUtil');
+
+module.exports = require('../common').runTest(test);
+
+function createWeakRef(binding, bindingToTest) {
+  return binding.object[bindingToTest]({});
+}
+
+function test(binding) {
+  let obj1;
+  let obj2;
+  return testUtil.runGCTests([
+    'addFinalizer',
+    () => {
+      obj1 = createWeakRef(binding, 'addFinalizer');
+    },
+    () => assert.deepStrictEqual(obj1, { finalizerCalled: true }),
+
+    'addFinalizerWithHint',
+    () => {
+      obj2 = createWeakRef(binding, 'addFinalizerWithHint');
+    },
+    () => assert.deepStrictEqual(obj2, { finalizerCalledWithCorrectHint: true })
+  ]);
+}