koffi 0.9.1 → 0.9.2

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

@@ -0,0 +1,22 @@
+#include "napi.h"
+
+using namespace Napi;
+
+#if (NAPI_VERSION > 2)
+namespace {
+
+static void RunInCallbackScope(const CallbackInfo& info) {
+  Function callback = info[0].As<Function>();
+  AsyncContext context(info.Env(), "callback_scope_test");
+  CallbackScope scope(info.Env(), context);
+  callback.Call({});
+}
+
+} // end anonymous namespace
+
+Object InitCallbackScope(Env env) {
+  Object exports = Object::New(env);
+  exports["runInCallbackScope"] = Function::New(env, RunInCallbackScope);
+  return exports;
+}
+#endif

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

@@ -0,0 +1,49 @@
+'use strict';
+const assert = require('assert');
+
+// we only check async hooks on 8.x an higher were
+// they are closer to working properly
+const nodeVersion = process.versions.node.split('.')[0]
+let async_hooks = undefined;
+function checkAsyncHooks() {
+  if (nodeVersion >= 8) {
+    if (async_hooks == undefined) {
+      async_hooks = require('async_hooks');
+    }
+    return true;
+  }
+  return false;
+}
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  if (!checkAsyncHooks())
+    return;
+
+  let id;
+  let insideHook = false;
+  const hook = async_hooks.createHook({
+    init(asyncId, type, triggerAsyncId, resource) {
+      if (id === undefined && type === 'callback_scope_test') {
+        id = asyncId;
+      }
+    },
+    before(asyncId) {
+      if (asyncId === id)
+        insideHook = true;
+    },
+    after(asyncId) {
+      if (asyncId === id)
+        insideHook = false;
+    }
+  }).enable();
+
+  return new Promise(resolve => {
+    binding.callbackscope.runInCallbackScope(function() {
+      assert(insideHook);
+      hook.disable();
+      resolve();
+    });
+  });
+}

package/vendor/node-addon-api/test/common/index.js

@@ -0,0 +1,113 @@
+/* Test helpers ported from test/common/index.js in Node.js project. */
+'use strict';
+const assert = require('assert');
+const path = require('path');
+
+const noop = () => {};
+
+const mustCallChecks = [];
+
+function runCallChecks(exitCode) {
+  if (exitCode !== 0) return;
+
+  const failed = mustCallChecks.filter(function(context) {
+    if ('minimum' in context) {
+      context.messageSegment = `at least ${context.minimum}`;
+      return context.actual < context.minimum;
+    } else {
+      context.messageSegment = `exactly ${context.exact}`;
+      return context.actual !== context.exact;
+    }
+  });
+
+  failed.forEach(function(context) {
+    console.log('Mismatched %s function calls. Expected %s, actual %d.',
+                context.name,
+                context.messageSegment,
+                context.actual);
+    console.log(context.stack.split('\n').slice(2).join('\n'));
+  });
+
+  if (failed.length) process.exit(1);
+}
+
+exports.mustCall = function(fn, exact) {
+  return _mustCallInner(fn, exact, 'exact');
+};
+exports.mustCallAtLeast = function(fn, minimum) {
+  return _mustCallInner(fn, minimum, 'minimum');
+};
+
+function _mustCallInner(fn, criteria, field) {
+  if (typeof fn === 'number') {
+    criteria = fn;
+    fn = noop;
+  } else if (fn === undefined) {
+    fn = noop;
+  }
+  if (criteria === undefined) {
+    criteria = 1;
+  }
+
+  if (typeof criteria !== 'number')
+    throw new TypeError(`Invalid ${field} value: ${criteria}`);
+
+  const context = {
+    [field]: criteria,
+    actual: 0,
+    stack: (new Error()).stack,
+    name: fn.name || '<anonymous>'
+  };
+
+  // add the exit listener only once to avoid listener leak warnings
+  if (mustCallChecks.length === 0) process.on('exit', runCallChecks);
+
+  mustCallChecks.push(context);
+
+  return function() {
+    context.actual++;
+    return fn.apply(this, arguments);
+  };
+}
+
+exports.mustNotCall = function(msg) {
+  return function mustNotCall() {
+    assert.fail(msg || 'function should not have been called');
+  };
+};
+
+exports.runTest = async function(test, buildType, buildPathRoot = process.env.REL_BUILD_PATH || '') {
+  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+
+  const bindings = [
+    path.join(buildPathRoot, `../build/${buildType}/binding.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
+  ].map(it => require.resolve(it));
+
+  for (const item of bindings) {
+    await Promise.resolve(test(require(item)))
+      .finally(exports.mustCall());
+  }
+}
+
+exports.runTestWithBindingPath = async function(test, buildType, buildPathRoot = process.env.REL_BUILD_PATH || '') {
+  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+
+  const bindings = [
+    path.join(buildPathRoot, `../build/${buildType}/binding.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
+  ].map(it => require.resolve(it));
+
+  for (const item of bindings) {
+    await test(item);
+  }
+}
+
+exports.runTestWithBuildType = async function(test, buildType) {
+  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+
+   await Promise.resolve(test(buildType))
+     .finally(exports.mustCall());
+}

package/vendor/node-addon-api/test/common/test_helper.h

@@ -0,0 +1,61 @@
+#pragma once
+#include "napi.h"
+
+namespace Napi {
+
+// Use this when a variable or parameter is unused in order to explicitly
+// silence a compiler warning about that.
+template <typename T>
+inline void USE(T&&) {}
+
+/**
+ * A test helper that converts MaybeOrValue<T> to T by checking that
+ * MaybeOrValue is NOT an empty Maybe when NODE_ADDON_API_ENABLE_MAYBE is
+ * defined.
+ *
+ * Do nothing when NODE_ADDON_API_ENABLE_MAYBE is not defined.
+ */
+template <typename T>
+inline T MaybeUnwrap(MaybeOrValue<T> maybe) {
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  return maybe.Unwrap();
+#else
+  return maybe;
+#endif
+}
+
+/**
+ * A test helper that converts MaybeOrValue<T> to T by getting the value that
+ * wrapped by the Maybe or return the default_value if the Maybe is empty when
+ * NODE_ADDON_API_ENABLE_MAYBE is defined.
+ *
+ * Do nothing when NODE_ADDON_API_ENABLE_MAYBE is not defined.
+ */
+template <typename T>
+inline T MaybeUnwrapOr(MaybeOrValue<T> maybe, const T& default_value) {
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  return maybe.UnwrapOr(default_value);
+#else
+  USE(default_value);
+  return maybe;
+#endif
+}
+
+/**
+ * A test helper that converts MaybeOrValue<T> to T by getting the value that
+ * wrapped by the Maybe or return false if the Maybe is empty when
+ * NODE_ADDON_API_ENABLE_MAYBE is defined.
+ *
+ * Copying the value to out when NODE_ADDON_API_ENABLE_MAYBE is not defined.
+ */
+template <typename T>
+inline bool MaybeUnwrapTo(MaybeOrValue<T> maybe, T* out) {
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  return maybe.UnwrapTo(out);
+#else
+  *out = maybe;
+  return true;
+#endif
+}
+
+}  // namespace Napi

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

@@ -0,0 +1,48 @@
+#include "napi.h"
+
+using namespace Napi;
+
+static Value CreateDataView1(const CallbackInfo& info) {
+  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
+  return DataView::New(info.Env(), arrayBuffer);
+}
+
+static Value CreateDataView2(const CallbackInfo& info) {
+  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return DataView::New(info.Env(), arrayBuffer, byteOffset);
+}
+
+static Value CreateDataView3(const CallbackInfo& info) {
+  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  size_t byteLength = info[2].As<Number>().Uint32Value();
+  return DataView::New(info.Env(), arrayBuffer, byteOffset, byteLength);
+}
+
+static Value GetArrayBuffer(const CallbackInfo& info) {
+  return info[0].As<DataView>().ArrayBuffer();
+}
+
+static Value GetByteOffset(const CallbackInfo& info) {
+  return Number::New(info.Env(),
+                     static_cast<double>(info[0].As<DataView>().ByteOffset()));
+}
+
+static Value GetByteLength(const CallbackInfo& info) {
+  return Number::New(info.Env(),
+                     static_cast<double>(info[0].As<DataView>().ByteLength()));
+}
+
+Object InitDataView(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createDataView1"] = Function::New(env, CreateDataView1);
+  exports["createDataView2"] = Function::New(env, CreateDataView2);
+  exports["createDataView3"] = Function::New(env, CreateDataView3);
+  exports["getArrayBuffer"] = Function::New(env, GetArrayBuffer);
+  exports["getByteOffset"] = Function::New(env, GetByteOffset);
+  exports["getByteLength"] = Function::New(env, GetByteLength);
+
+  return exports;
+}

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

@@ -0,0 +1,35 @@
+'use strict';
+
+const assert = require('assert');
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function testDataViewCreation(factory, arrayBuffer, offset, length) {
+    const view = factory(arrayBuffer, offset, length);
+    offset = offset ? offset : 0;
+    assert.ok(dataview.getArrayBuffer(view) instanceof ArrayBuffer);
+    assert.strictEqual(dataview.getArrayBuffer(view), arrayBuffer);
+    assert.strictEqual(dataview.getByteOffset(view), offset);
+    assert.strictEqual(dataview.getByteLength(view),
+        length ? length : arrayBuffer.byteLength - offset);
+  }
+
+  function testInvalidRange(factory, arrayBuffer, offset, length) {
+    assert.throws(() => {
+      factory(arrayBuffer, offset, length);
+    }, RangeError);
+  }
+
+  const dataview = binding.dataview;
+  const arrayBuffer = new ArrayBuffer(10);
+
+  testDataViewCreation(dataview.createDataView1, arrayBuffer);
+  testDataViewCreation(dataview.createDataView2, arrayBuffer, 2);
+  testDataViewCreation(dataview.createDataView2, arrayBuffer, 10);
+  testDataViewCreation(dataview.createDataView3, arrayBuffer, 2, 4);
+  testDataViewCreation(dataview.createDataView3, arrayBuffer, 10, 0);
+
+  testInvalidRange(dataview.createDataView2, arrayBuffer, 11);
+  testInvalidRange(dataview.createDataView3, arrayBuffer, 11, 0);
+  testInvalidRange(dataview.createDataView3, arrayBuffer, 6, 5);
+}

package/vendor/node-addon-api/test/dataview/dataview_read_write.cc

@@ -0,0 +1,115 @@
+#include "napi.h"
+
+using namespace Napi;
+
+static Value GetFloat32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetFloat32(byteOffset));
+}
+
+static Value GetFloat64(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetFloat64(byteOffset));
+}
+
+static Value GetInt8(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetInt8(byteOffset));
+}
+
+static Value GetInt16(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetInt16(byteOffset));
+}
+
+static Value GetInt32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetInt32(byteOffset));
+}
+
+static Value GetUint8(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetUint8(byteOffset));
+}
+
+static Value GetUint16(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetUint16(byteOffset));
+}
+
+static Value GetUint32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetUint32(byteOffset));
+}
+
+static void SetFloat32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().FloatValue();
+  info[0].As<DataView>().SetFloat32(byteOffset, value);
+}
+
+static void SetFloat64(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().DoubleValue();
+  info[0].As<DataView>().SetFloat64(byteOffset, value);
+}
+
+static void SetInt8(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Int32Value();
+  info[0].As<DataView>().SetInt8(byteOffset, value);
+}
+
+static void SetInt16(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Int32Value();
+  info[0].As<DataView>().SetInt16(byteOffset, value);
+}
+
+static void SetInt32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Int32Value();
+  info[0].As<DataView>().SetInt32(byteOffset, value);
+}
+
+static void SetUint8(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Uint32Value();
+  info[0].As<DataView>().SetUint8(byteOffset, value);
+}
+
+static void SetUint16(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Uint32Value();
+  info[0].As<DataView>().SetUint16(byteOffset, value);
+}
+
+static void SetUint32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Uint32Value();
+  info[0].As<DataView>().SetUint32(byteOffset, value);
+}
+
+Object InitDataViewReadWrite(Env env) {
+  Object exports = Object::New(env);
+
+  exports["getFloat32"] = Function::New(env, GetFloat32);
+  exports["getFloat64"] = Function::New(env, GetFloat64);
+  exports["getInt8"] = Function::New(env, GetInt8);
+  exports["getInt16"] = Function::New(env, GetInt16);
+  exports["getInt32"] = Function::New(env, GetInt32);
+  exports["getUint8"] = Function::New(env, GetUint8);
+  exports["getUint16"] = Function::New(env, GetUint16);
+  exports["getUint32"] = Function::New(env, GetUint32);
+
+  exports["setFloat32"] = Function::New(env, SetFloat32);
+  exports["setFloat64"] = Function::New(env, SetFloat64);
+  exports["setInt8"] = Function::New(env, SetInt8);
+  exports["setInt16"] = Function::New(env, SetInt16);
+  exports["setInt32"] = Function::New(env, SetInt32);
+  exports["setUint8"] = Function::New(env, SetUint8);
+  exports["setUint16"] = Function::New(env, SetUint16);
+  exports["setUint32"] = Function::New(env, SetUint32);
+
+  return exports;
+}

package/vendor/node-addon-api/test/dataview/dataview_read_write.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function expected(type, value) {
+    return eval(`(new ${type}Array([${value}]))[0]`);
+  }
+
+  function nativeReadDataView(dataview, type, offset, value) {
+    return eval(`binding.dataview_read_write.get${type}(dataview, offset)`);
+  }
+
+  function nativeWriteDataView(dataview, type, offset, value) {
+    eval(`binding.dataview_read_write.set${type}(dataview, offset, value)`);
+  }
+
+  function isLittleEndian() {
+    const buffer = new ArrayBuffer(2);
+    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
+    return new Int16Array(buffer)[0] === 256;
+  }
+
+  function jsReadDataView(dataview, type, offset, value) {
+    return eval(`dataview.get${type}(offset, isLittleEndian())`);
+  }
+
+  function jsWriteDataView(dataview, type, offset, value) {
+    eval(`dataview.set${type}(offset, value, isLittleEndian())`);
+  }
+
+  function testReadData(dataview, type, offset, value) {
+    jsWriteDataView(dataview, type, offset, 0);
+    assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
+
+    jsWriteDataView(dataview, type, offset, value);
+    assert.strictEqual(
+        nativeReadDataView(dataview, type, offset), expected(type, value));
+  }
+
+  function testWriteData(dataview, type, offset, value) {
+    jsWriteDataView(dataview, type, offset, 0);
+    assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
+
+    nativeWriteDataView(dataview, type, offset, value);
+    assert.strictEqual(
+        jsReadDataView(dataview, type, offset), expected(type, value));
+  }
+
+  function testInvalidOffset(dataview, type, offset, value) {
+    assert.throws(() => {
+      nativeReadDataView(dataview, type, offset);
+    }, RangeError);
+
+    assert.throws(() => {
+      nativeWriteDataView(dataview, type, offset, value);
+    }, RangeError);
+  }
+
+  const dataview = new DataView(new ArrayBuffer(22));
+
+  testReadData(dataview, 'Float32', 0, 10.2);
+  testReadData(dataview, 'Float64', 4, 20.3);
+  testReadData(dataview, 'Int8', 5, 120);
+  testReadData(dataview, 'Int16', 7, 15000);
+  testReadData(dataview, 'Int32', 11, 200000);
+  testReadData(dataview, 'Uint8', 12, 128);
+  testReadData(dataview, 'Uint16', 14, 32768);
+  testReadData(dataview, 'Uint32', 18, 1000000);
+
+  testWriteData(dataview, 'Float32', 0, 10.2);
+  testWriteData(dataview, 'Float64', 4, 20.3);
+  testWriteData(dataview, 'Int8', 5, 120);
+  testWriteData(dataview, 'Int16', 7, 15000);
+  testWriteData(dataview, 'Int32', 11, 200000);
+  testWriteData(dataview, 'Uint8', 12, 128);
+  testWriteData(dataview, 'Uint16', 14, 32768);
+  testWriteData(dataview, 'Uint32', 18, 1000000);
+
+  testInvalidOffset(dataview, 'Float32', 22, 10.2);
+  testInvalidOffset(dataview, 'Float64', 22, 20.3);
+  testInvalidOffset(dataview, 'Int8', 22, 120);
+  testInvalidOffset(dataview, 'Int16', 22, 15000);
+  testInvalidOffset(dataview, 'Int32', 22, 200000);
+  testInvalidOffset(dataview, 'Uint8', 22, 128);
+  testInvalidOffset(dataview, 'Uint16', 22, 32768);
+  testInvalidOffset(dataview, 'Uint32', 22, 1000000);
+}

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

@@ -0,0 +1,44 @@
+#include "napi.h"
+
+using namespace Napi;
+
+#if (NAPI_VERSION > 4)
+namespace {
+
+Value CreateDate(const CallbackInfo& info) {
+  double input = info[0].As<Number>().DoubleValue();
+
+  return Date::New(info.Env(), input);
+}
+
+Value IsDate(const CallbackInfo& info) {
+  Date input = info[0].As<Date>();
+
+  return Boolean::New(info.Env(), input.IsDate());
+}
+
+Value ValueOf(const CallbackInfo& info) {
+  Date input = info[0].As<Date>();
+
+  return Number::New(info.Env(), input.ValueOf());
+}
+
+Value OperatorValue(const CallbackInfo& info) {
+  Date input = info[0].As<Date>();
+
+  return Boolean::New(info.Env(), input.ValueOf() == static_cast<double>(input));
+}
+
+}  // anonymous namespace
+
+Object InitDate(Env env) {
+  Object exports = Object::New(env);
+  exports["CreateDate"] = Function::New(env, CreateDate);
+  exports["IsDate"] = Function::New(env, IsDate);
+  exports["ValueOf"] = Function::New(env, ValueOf);
+  exports["OperatorValue"] = Function::New(env, OperatorValue);
+
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,18 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  const {
+    CreateDate,
+    IsDate,
+    ValueOf,
+    OperatorValue,
+  } = binding.date;
+  assert.deepStrictEqual(CreateDate(0), new Date(0));
+  assert.strictEqual(IsDate(new Date(0)), true);
+  assert.strictEqual(ValueOf(new Date(42)), 42);
+  assert.strictEqual(OperatorValue(new Date(42)), true);
+}

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

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include "napi.h"
+
+using namespace Napi;
+
+#if (NAPI_VERSION > 2)
+namespace {
+
+static void cleanup(void* arg) {
+  printf("static cleanup(%d)\n", *(int*)(arg));
+}
+static void cleanupInt(int* arg) {
+  printf("static cleanup(%d)\n", *(arg));
+}
+
+static void cleanupVoid() {
+  printf("static cleanup()\n");
+}
+
+static int secret1 = 42;
+static int secret2 = 43;
+
+Value AddHooks(const CallbackInfo& info) {
+  auto env = info.Env();
+
+  bool shouldRemove = info[0].As<Boolean>().Value();
+
+  // hook: void (*)(void *arg), hint: int
+  auto hook1 = env.AddCleanupHook(cleanup, &secret1);
+  // test using same hook+arg pair
+  auto hook1b = env.AddCleanupHook(cleanup, &secret1);
+
+  // hook: void (*)(int *arg), hint: int
+  auto hook2 = env.AddCleanupHook(cleanupInt, &secret2);
+
+  // hook: void (*)(int *arg), hint: void (default)
+  auto hook3 = env.AddCleanupHook(cleanupVoid);
+  // test using the same hook
+  auto hook3b = env.AddCleanupHook(cleanupVoid);
+
+  // hook: lambda []void (int *arg)->void, hint: int
+  auto hook4 = env.AddCleanupHook(
+      [&](int* arg) { printf("lambda cleanup(%d)\n", *arg); }, &secret1);
+
+  // hook: lambda []void (void *)->void, hint: void
+  auto hook5 =
+      env.AddCleanupHook([&](void*) { printf("lambda cleanup(void)\n"); },
+                         static_cast<void*>(nullptr));
+
+  // hook: lambda []void ()->void, hint: void (default)
+  auto hook6 = env.AddCleanupHook([&]() { printf("lambda cleanup()\n"); });
+
+  if (shouldRemove) {
+    hook1.Remove(env);
+    hook1b.Remove(env);
+    hook2.Remove(env);
+    hook3.Remove(env);
+    hook3b.Remove(env);
+    hook4.Remove(env);
+    hook5.Remove(env);
+    hook6.Remove(env);
+  }
+
+  int added = 0;
+
+  added += !hook1.IsEmpty();
+  added += !hook1b.IsEmpty();
+  added += !hook2.IsEmpty();
+  added += !hook3.IsEmpty();
+  added += !hook3b.IsEmpty();
+  added += !hook4.IsEmpty();
+  added += !hook5.IsEmpty();
+  added += !hook6.IsEmpty();
+
+  return Number::New(env, added);
+}
+
+}  // anonymous namespace
+
+Object InitEnvCleanup(Env env) {
+  Object exports = Object::New(env);
+
+  exports["addHooks"] = Function::New(env, AddHooks);
+
+  return exports;
+}
+
+#endif