koffi 0.9.4 → 0.9.5

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_threadsafe_function_unref.cc

@@ -1,53 +1,53 @@
-#include "napi.h"
-#include "test_helper.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-using TSFN = TypedThreadSafeFunction<>;
-using ContextType = std::nullptr_t;
-using FinalizerDataType = void;
-static Value TestUnref(const CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Object global = env.Global();
-  Object resource = info[0].As<Object>();
-  Function cb = info[1].As<Function>();
-  Function setTimeout = MaybeUnwrap(global.Get("setTimeout")).As<Function>();
-  TSFN* tsfn = new TSFN;
-
-  *tsfn = TSFN::New(
-      info.Env(),
-      cb,
-      resource,
-      "Test",
-      1,
-      1,
-      nullptr,
-      [tsfn](Napi::Env /* env */, FinalizerDataType*, ContextType*) {
-        delete tsfn;
-      },
-      static_cast<FinalizerDataType*>(nullptr));
-
-  tsfn->BlockingCall();
-
-  setTimeout.Call(
-      global,
-      {Function::New(
-           env, [tsfn](const CallbackInfo& info) { tsfn->Unref(info.Env()); }),
-       Number::New(env, 100)});
-
-  return info.Env().Undefined();
-}
-
-}  // namespace
-
-Object InitTypedThreadSafeFunctionUnref(Env env) {
-  Object exports = Object::New(env);
-  exports["testUnref"] = Function::New(env, TestUnref);
-  return exports;
-}
-
-#endif
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+using TSFN = TypedThreadSafeFunction<>;
+using ContextType = std::nullptr_t;
+using FinalizerDataType = void;
+static Value TestUnref(const CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Object global = env.Global();
+  Object resource = info[0].As<Object>();
+  Function cb = info[1].As<Function>();
+  Function setTimeout = MaybeUnwrap(global.Get("setTimeout")).As<Function>();
+  TSFN* tsfn = new TSFN;
+
+  *tsfn = TSFN::New(
+      info.Env(),
+      cb,
+      resource,
+      "Test",
+      1,
+      1,
+      nullptr,
+      [tsfn](Napi::Env /* env */, FinalizerDataType*, ContextType*) {
+        delete tsfn;
+      },
+      static_cast<FinalizerDataType*>(nullptr));
+
+  tsfn->BlockingCall();
+
+  setTimeout.Call(
+      global,
+      {Function::New(
+           env, [tsfn](const CallbackInfo& info) { tsfn->Unref(info.Env()); }),
+       Number::New(env, 100)});
+
+  return info.Env().Undefined();
+}
+
+}  // namespace
+
+Object InitTypedThreadSafeFunctionUnref(Env env) {
+  Object exports = Object::New(env);
+  exports["testUnref"] = Function::New(env, TestUnref);
+  return exports;
+}
+
+#endif

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_threadsafe_function_unref.js

@@ -1,53 +1,53 @@
-'use strict';
-
-const assert = require('assert');
-
-const isMainProcess = process.argv[1] != __filename;
-
-/**
- * In order to test that the event loop exits even with an active TSFN, we need
- * to spawn a new process for the test.
- *   - Main process: spawns new node instance, executing this script
- *   - Child process: creates TSFN. Native module Unref's via setTimeout after some time but does NOT call Release.
- *
- * Main process should expect child process to exit.
- */
-
-if (isMainProcess) {
-  module.exports = require('../common').runTestWithBindingPath(test);
-} else {
-  test(process.argv[2]);
-}
-
-function test(bindingFile) {
-  if (isMainProcess) {
-    // Main process
-    return new Promise((resolve, reject) => {
-      const child = require('../napi_child').spawn(process.argv[0], [
-        '--expose-gc', __filename, bindingFile
-      ], { stdio: 'inherit' });
-
-      let timeout = setTimeout( function() {
-        child.kill();
-        timeout = 0;
-        reject(new Error("Expected child to die"));
-      }, 5000);
-
-      child.on("error", (err) => {
-        clearTimeout(timeout);
-        timeout = 0;
-        reject(new Error(err));
-      })
-
-      child.on("close", (code) => {
-        if (timeout) clearTimeout(timeout);
-        assert.strictEqual(code, 0, "Expected return value 0");
-        resolve();
-      });
-    });
-  } else {
-    // Child process
-    const binding = require(bindingFile);
-    binding.typed_threadsafe_function_unref.testUnref({}, () => { });
-  }
-}
+'use strict';
+
+const assert = require('assert');
+
+const isMainProcess = process.argv[1] != __filename;
+
+/**
+ * In order to test that the event loop exits even with an active TSFN, we need
+ * to spawn a new process for the test.
+ *   - Main process: spawns new node instance, executing this script
+ *   - Child process: creates TSFN. Native module Unref's via setTimeout after some time but does NOT call Release.
+ *
+ * Main process should expect child process to exit.
+ */
+
+if (isMainProcess) {
+  module.exports = require('../common').runTestWithBindingPath(test);
+} else {
+  test(process.argv[2]);
+}
+
+function test(bindingFile) {
+  if (isMainProcess) {
+    // Main process
+    return new Promise((resolve, reject) => {
+      const child = require('../napi_child').spawn(process.argv[0], [
+        '--expose-gc', __filename, bindingFile
+      ], { stdio: 'inherit' });
+
+      let timeout = setTimeout( function() {
+        child.kill();
+        timeout = 0;
+        reject(new Error("Expected child to die"));
+      }, 5000);
+
+      child.on("error", (err) => {
+        clearTimeout(timeout);
+        timeout = 0;
+        reject(new Error(err));
+      })
+
+      child.on("close", (code) => {
+        if (timeout) clearTimeout(timeout);
+        assert.strictEqual(code, 0, "Expected return value 0");
+        resolve();
+      });
+    });
+  } else {
+    // Child process
+    const binding = require(bindingFile);
+    binding.typed_threadsafe_function_unref.testUnref({}, () => { });
+  }
+}

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

@@ -1,58 +1,58 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  [
-    ['bigint64', BigInt64Array],
-    ['biguint64', BigUint64Array],
-  ].forEach(([type, Constructor]) => {
-    try {
-      const length = 4;
-      const t = binding.typedarray.createTypedArray(type, length);
-      assert.ok(t instanceof Constructor);
-      assert.strictEqual(binding.typedarray.getTypedArrayType(t), type);
-      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
-
-      t[3] = 11n;
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
-      binding.typedarray.setTypedArrayElement(t, 3, 22n);
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
-      assert.strictEqual(t[3], 22n);
-
-      const b = binding.typedarray.getTypedArrayBuffer(t);
-      assert.ok(b instanceof ArrayBuffer);
-    } catch (e) {
-      console.log(type, Constructor);
-      throw e;
-    }
-
-    try {
-      const length = 4;
-      const offset = 8;
-      const b = new ArrayBuffer(offset + 64 * 4);
-
-      const t = binding.typedarray.createTypedArray(type, length, b, offset);
-      assert.ok(t instanceof Constructor);
-      assert.strictEqual(binding.typedarray.getTypedArrayType(t), type);
-      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
-
-      t[3] = 11n;
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
-      binding.typedarray.setTypedArrayElement(t, 3, 22n);
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
-      assert.strictEqual(t[3], 22n);
-
-      assert.strictEqual(binding.typedarray.getTypedArrayBuffer(t), b);
-    } catch (e) {
-      console.log(type, Constructor);
-      throw e;
-    }
-  });
-
-  assert.throws(() => {
-    binding.typedarray.createInvalidTypedArray();
-  }, /Invalid (pointer passed as )?argument/);
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  [
+    ['bigint64', BigInt64Array],
+    ['biguint64', BigUint64Array],
+  ].forEach(([type, Constructor]) => {
+    try {
+      const length = 4;
+      const t = binding.typedarray.createTypedArray(type, length);
+      assert.ok(t instanceof Constructor);
+      assert.strictEqual(binding.typedarray.getTypedArrayType(t), type);
+      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
+
+      t[3] = 11n;
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
+      binding.typedarray.setTypedArrayElement(t, 3, 22n);
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
+      assert.strictEqual(t[3], 22n);
+
+      const b = binding.typedarray.getTypedArrayBuffer(t);
+      assert.ok(b instanceof ArrayBuffer);
+    } catch (e) {
+      console.log(type, Constructor);
+      throw e;
+    }
+
+    try {
+      const length = 4;
+      const offset = 8;
+      const b = new ArrayBuffer(offset + 64 * 4);
+
+      const t = binding.typedarray.createTypedArray(type, length, b, offset);
+      assert.ok(t instanceof Constructor);
+      assert.strictEqual(binding.typedarray.getTypedArrayType(t), type);
+      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
+
+      t[3] = 11n;
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
+      binding.typedarray.setTypedArrayElement(t, 3, 22n);
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
+      assert.strictEqual(t[3], 22n);
+
+      assert.strictEqual(binding.typedarray.getTypedArrayBuffer(t), b);
+    } catch (e) {
+      console.log(type, Constructor);
+      throw e;
+    }
+  });
+
+  assert.throws(() => {
+    binding.typedarray.createInvalidTypedArray();
+  }, /Invalid (pointer passed as )?argument/);
+}