koffi 0.9.3 → 0.9.6

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

@@ -1,188 +1,188 @@
-'use strict';
-
-const assert = require('assert');
-const common = require('../common');
-
-module.exports = common.runTest(test);
-
-async function test(binding) {
-  const expectedArray = (function (arrayLength) {
-    const result = [];
-    for (let index = 0; index < arrayLength; index++) {
-      result.push(arrayLength - 1 - index);
-    }
-    return result;
-  })(binding.typed_threadsafe_function.ARRAY_LENGTH);
-
-  function testWithJSMarshaller({
-    threadStarter,
-    quitAfter,
-    abort,
-    maxQueueSize,
-    launchSecondary }) {
-    return new Promise((resolve) => {
-      const array = [];
-      binding.typed_threadsafe_function[threadStarter](function testCallback(value) {
-        array.push(value);
-        if (array.length === quitAfter) {
-          binding.typed_threadsafe_function.stopThread(common.mustCall(() => {
-            resolve(array);
-          }), !!abort);
-        }
-      }, !!abort, !!launchSecondary, maxQueueSize);
-      if (threadStarter === 'startThreadNonblocking') {
-        // Let's make this thread really busy for a short while to ensure that
-        // the queue fills and the thread receives a napi_queue_full.
-        const start = Date.now();
-        while (Date.now() - start < 200);
-      }
-    });
-  }
-
-  await new Promise(function testWithoutJSMarshaller(resolve) {
-    let callCount = 0;
-    binding.typed_threadsafe_function.startThreadNoNative(function testCallback() {
-      callCount++;
-
-      // The default call-into-JS implementation passes no arguments.
-      assert.strictEqual(arguments.length, 0);
-      if (callCount === binding.typed_threadsafe_function.ARRAY_LENGTH) {
-        setImmediate(() => {
-          binding.typed_threadsafe_function.stopThread(common.mustCall(() => {
-            resolve();
-          }), false);
-        });
-      }
-    }, false /* abort */, false /* launchSecondary */,
-      binding.typed_threadsafe_function.MAX_QUEUE_SIZE);
-  });
-
-  // Start the thread in blocking mode, and assert that all values are passed.
-  // Quit after it's done.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode with an infinite queue, and assert that
-  // all values are passed. Quit after it's done.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      maxQueueSize: 0,
-      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in non-blocking mode, and assert that all values are
-  // passed. Quit after it's done.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblocking',
-      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode, and assert that all values are passed.
-  // Quit early, but let the thread finish.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: 1
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode with an infinite queue, and assert that
-  // all values are passed. Quit early, but let the thread finish.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      maxQueueSize: 0,
-      quitAfter: 1
-    }),
-    expectedArray,
-  );
-
-
-  // Start the thread in non-blocking mode, and assert that all values are
-  // passed. Quit early, but let the thread finish.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblocking',
-      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: 1
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode, and assert that all values are passed.
-  // Quit early, but let the thread finish. Launch a secondary thread to test
-  // the reference counter incrementing functionality.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      quitAfter: 1,
-      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
-      launchSecondary: true
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in non-blocking mode, and assert that all values are
-  // passed. Quit early, but let the thread finish. Launch a secondary thread
-  // to test the reference counter incrementing functionality.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblocking',
-      quitAfter: 1,
-      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
-      launchSecondary: true
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode, and assert that it could not finish.
-  // Quit early by aborting.
-  assert.strictEqual(
-    (await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      quitAfter: 1,
-      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
-      abort: true
-    })).indexOf(0),
-    -1,
-  );
-
-  // Start the thread in blocking mode with an infinite queue, and assert that
-  // it could not finish. Quit early by aborting.
-  assert.strictEqual(
-    (await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      quitAfter: 1,
-      maxQueueSize: 0,
-      abort: true
-    })).indexOf(0),
-    -1,
-  );
-
-  // Start the thread in non-blocking mode, and assert that it could not finish.
-  // Quit early and aborting.
-  assert.strictEqual(
-    (await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblocking',
-      quitAfter: 1,
-      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
-      abort: true
-    })).indexOf(0),
-    -1,
-  );
-}
+'use strict';
+
+const assert = require('assert');
+const common = require('../common');
+
+module.exports = common.runTest(test);
+
+async function test(binding) {
+  const expectedArray = (function (arrayLength) {
+    const result = [];
+    for (let index = 0; index < arrayLength; index++) {
+      result.push(arrayLength - 1 - index);
+    }
+    return result;
+  })(binding.typed_threadsafe_function.ARRAY_LENGTH);
+
+  function testWithJSMarshaller({
+    threadStarter,
+    quitAfter,
+    abort,
+    maxQueueSize,
+    launchSecondary }) {
+    return new Promise((resolve) => {
+      const array = [];
+      binding.typed_threadsafe_function[threadStarter](function testCallback(value) {
+        array.push(value);
+        if (array.length === quitAfter) {
+          binding.typed_threadsafe_function.stopThread(common.mustCall(() => {
+            resolve(array);
+          }), !!abort);
+        }
+      }, !!abort, !!launchSecondary, maxQueueSize);
+      if (threadStarter === 'startThreadNonblocking') {
+        // Let's make this thread really busy for a short while to ensure that
+        // the queue fills and the thread receives a napi_queue_full.
+        const start = Date.now();
+        while (Date.now() - start < 200);
+      }
+    });
+  }
+
+  await new Promise(function testWithoutJSMarshaller(resolve) {
+    let callCount = 0;
+    binding.typed_threadsafe_function.startThreadNoNative(function testCallback() {
+      callCount++;
+
+      // The default call-into-JS implementation passes no arguments.
+      assert.strictEqual(arguments.length, 0);
+      if (callCount === binding.typed_threadsafe_function.ARRAY_LENGTH) {
+        setImmediate(() => {
+          binding.typed_threadsafe_function.stopThread(common.mustCall(() => {
+            resolve();
+          }), false);
+        });
+      }
+    }, false /* abort */, false /* launchSecondary */,
+      binding.typed_threadsafe_function.MAX_QUEUE_SIZE);
+  });
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // all values are passed. Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: 0,
+      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // all values are passed. Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: 0,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish. Launch a secondary thread to test
+  // the reference counter incrementing functionality.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      launchSecondary: true
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit early, but let the thread finish. Launch a secondary thread
+  // to test the reference counter incrementing functionality.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      quitAfter: 1,
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      launchSecondary: true
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that it could not finish.
+  // Quit early by aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // it could not finish. Quit early by aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: 0,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+
+  // Start the thread in non-blocking mode, and assert that it could not finish.
+  // Quit early and aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      quitAfter: 1,
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+}

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

@@ -1,68 +1,68 @@
-#include "napi.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-using ContextType = Reference<Napi::Value>;
-using TSFN = TypedThreadSafeFunction<ContextType>;
-
-namespace {
-
-class TSFNWrap : public ObjectWrap<TSFNWrap> {
- public:
-  static Object Init(Napi::Env env, Object exports);
-  TSFNWrap(const CallbackInfo& info);
-
-  Napi::Value GetContext(const CallbackInfo& /*info*/) {
-    ContextType* ctx = _tsfn.GetContext();
-    return ctx->Value();
-  };
-
-  Napi::Value Release(const CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    _deferred = std::unique_ptr<Promise::Deferred>(new Promise::Deferred(env));
-    _tsfn.Release();
-    return _deferred->Promise();
-  };
-
- private:
-  TSFN _tsfn;
-  std::unique_ptr<Promise::Deferred> _deferred;
-};
-
-Object TSFNWrap::Init(Napi::Env env, Object exports) {
-  Function func =
-      DefineClass(env,
-                  "TSFNWrap",
-                  {InstanceMethod("getContext", &TSFNWrap::GetContext),
-                   InstanceMethod("release", &TSFNWrap::Release)});
-
-  exports.Set("TSFNWrap", func);
-  return exports;
-}
-
-TSFNWrap::TSFNWrap(const CallbackInfo& info) : ObjectWrap<TSFNWrap>(info) {
-  ContextType* _ctx = new ContextType;
-  *_ctx = Persistent(info[0]);
-
-  _tsfn = TSFN::New(info.Env(),
-                    this->Value(),
-                    "Test",
-                    1,
-                    1,
-                    _ctx,
-                    [this](Napi::Env env, void*, ContextType* ctx) {
-                      _deferred->Resolve(env.Undefined());
-                      ctx->Reset();
-                      delete ctx;
-                    });
-}
-
-}  // namespace
-
-Object InitTypedThreadSafeFunctionCtx(Env env) {
-  return TSFNWrap::Init(env, Object::New(env));
-}
-
-#endif
+#include "napi.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+using ContextType = Reference<Napi::Value>;
+using TSFN = TypedThreadSafeFunction<ContextType>;
+
+namespace {
+
+class TSFNWrap : public ObjectWrap<TSFNWrap> {
+ public:
+  static Object Init(Napi::Env env, Object exports);
+  TSFNWrap(const CallbackInfo& info);
+
+  Napi::Value GetContext(const CallbackInfo& /*info*/) {
+    ContextType* ctx = _tsfn.GetContext();
+    return ctx->Value();
+  };
+
+  Napi::Value Release(const CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    _deferred = std::unique_ptr<Promise::Deferred>(new Promise::Deferred(env));
+    _tsfn.Release();
+    return _deferred->Promise();
+  };
+
+ private:
+  TSFN _tsfn;
+  std::unique_ptr<Promise::Deferred> _deferred;
+};
+
+Object TSFNWrap::Init(Napi::Env env, Object exports) {
+  Function func =
+      DefineClass(env,
+                  "TSFNWrap",
+                  {InstanceMethod("getContext", &TSFNWrap::GetContext),
+                   InstanceMethod("release", &TSFNWrap::Release)});
+
+  exports.Set("TSFNWrap", func);
+  return exports;
+}
+
+TSFNWrap::TSFNWrap(const CallbackInfo& info) : ObjectWrap<TSFNWrap>(info) {
+  ContextType* _ctx = new ContextType;
+  *_ctx = Persistent(info[0]);
+
+  _tsfn = TSFN::New(info.Env(),
+                    this->Value(),
+                    "Test",
+                    1,
+                    1,
+                    _ctx,
+                    [this](Napi::Env env, void*, ContextType* ctx) {
+                      _deferred->Resolve(env.Undefined());
+                      ctx->Reset();
+                      delete ctx;
+                    });
+}
+
+}  // namespace
+
+Object InitTypedThreadSafeFunctionCtx(Env env) {
+  return TSFNWrap::Init(env, Object::New(env));
+}
+
+#endif

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

@@ -1,12 +1,12 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-async function test(binding) {
-  const ctx = { };
-  const tsfn = new binding.threadsafe_function_ctx.TSFNWrap(ctx);
-  assert(tsfn.getContext() === ctx);
-  await tsfn.release();
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+async function test(binding) {
+  const ctx = { };
+  const tsfn = new binding.threadsafe_function_ctx.TSFNWrap(ctx);
+  assert(tsfn.getContext() === ctx);
+  await tsfn.release();
+}