koffi 0.9.4 → 0.9.5

package/vendor/node-addon-api/test/threadsafe_function/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.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.threadsafe_function_unref.testUnref({}, () => { });
+  }
+}

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

@@ -1,140 +1,140 @@
-#include <napi.h>
-
-// The formulaic comment below should accompany any code that results in an
-// internal piece of heap data getting created, because each such piece of heap
-// data must be attached to an object by way of a deleter which gets called when
-// the object gets garbage-collected.
-//
-// At the very least, you can add a fprintf(stderr, ...) to the deleter in
-// napi-inl.h and then count the number of times the deleter prints by running
-// node --expose-gc test/thunking_manual.js and counting the number of prints
-// between the two rows of dashes. That number should coincide with the number
-// of formulaic comments below.
-//
-// Note that currently this result can only be achieved with node-chakracore,
-// because V8 does not garbage-collect classes.
-
-static Napi::Value TestMethod(const Napi::CallbackInfo& /*info*/) {
-  return Napi::Value();
-}
-
-static Napi::Value TestGetter(const Napi::CallbackInfo& /*info*/) {
-  return Napi::Value();
-}
-
-static void TestSetter(const Napi::CallbackInfo& /*info*/) {
-}
-
-class TestClass : public Napi::ObjectWrap<TestClass> {
- public:
-  TestClass(const Napi::CallbackInfo& info):
-      ObjectWrap<TestClass>(info) {
-  }
-  static Napi::Value TestClassStaticMethod(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), 42);
-  }
-
-  static void TestClassStaticVoidMethod(const Napi::CallbackInfo& /*info*/) {
-  }
-
-  Napi::Value TestClassInstanceMethod(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), 42);
-  }
-
-  void TestClassInstanceVoidMethod(const Napi::CallbackInfo& /*info*/) {
-  }
-
-  Napi::Value TestClassInstanceGetter(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), 42);
-  }
-
-  void TestClassInstanceSetter(const Napi::CallbackInfo& /*info*/,
-                               const Napi::Value& /*new_value*/) {
-  }
-
-  static Napi::Function NewClass(Napi::Env env) {
-    return DefineClass(env, "TestClass", {
-      // Make sure to check that the deleter gets called.
-      StaticMethod("staticMethod", TestClassStaticMethod),
-      // Make sure to check that the deleter gets called.
-      StaticMethod("staticVoidMethod", TestClassStaticVoidMethod),
-      // Make sure to check that the deleter gets called.
-      StaticMethod(Napi::Symbol::New(env, "staticMethod"),
-                   TestClassStaticMethod),
-      // Make sure to check that the deleter gets called.
-      StaticMethod(Napi::Symbol::New(env, "staticVoidMethod"),
-                   TestClassStaticVoidMethod),
-      // Make sure to check that the deleter gets called.
-      InstanceMethod("instanceMethod", &TestClass::TestClassInstanceMethod),
-      // Make sure to check that the deleter gets called.
-      InstanceMethod("instanceVoidMethod",
-                     &TestClass::TestClassInstanceVoidMethod),
-      // Make sure to check that the deleter gets called.
-      InstanceMethod(Napi::Symbol::New(env, "instanceMethod"),
-                     &TestClass::TestClassInstanceMethod),
-      // Make sure to check that the deleter gets called.
-      InstanceMethod(Napi::Symbol::New(env, "instanceVoidMethod"),
-                     &TestClass::TestClassInstanceVoidMethod),
-      // Make sure to check that the deleter gets called.
-      InstanceAccessor("instanceAccessor",
-                       &TestClass::TestClassInstanceGetter,
-                       &TestClass::TestClassInstanceSetter)
-    });
-  }
-};
-
-static Napi::Value CreateTestObject(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::Object item = Napi::Object::New(env);
-
-  // Make sure to check that the deleter gets called.
-  item["testMethod"] = Napi::Function::New(env, TestMethod, "testMethod");
-
-  item.DefineProperties({
-    // Make sure to check that the deleter gets called.
-    Napi::PropertyDescriptor::Accessor(env,
-                                       item,
-                                       "accessor_1",
-                                       TestGetter),
-    // Make sure to check that the deleter gets called.
-    Napi::PropertyDescriptor::Accessor(env,
-                                       item,
-                                       std::string("accessor_1_std_string"),
-                                       TestGetter),
-    // Make sure to check that the deleter gets called.
-    Napi::PropertyDescriptor::Accessor(env,
-                                       item,
-                                       Napi::String::New(info.Env(),
-                                                        "accessor_1_js_string"),
-                                       TestGetter),
-    // Make sure to check that the deleter gets called.
-    Napi::PropertyDescriptor::Accessor(env,
-                                       item,
-                                       "accessor_2",
-                                       TestGetter,
-                                       TestSetter),
-    // Make sure to check that the deleter gets called.
-    Napi::PropertyDescriptor::Accessor(env,
-                                       item,
-                                       std::string("accessor_2_std_string"),
-                                       TestGetter,
-                                       TestSetter),
-    // Make sure to check that the deleter gets called.
-    Napi::PropertyDescriptor::Accessor(env,
-                                       item,
-                                       Napi::String::New(env,
-                                                        "accessor_2_js_string"),
-                                       TestGetter,
-                                       TestSetter),
-    Napi::PropertyDescriptor::Value("TestClass", TestClass::NewClass(env)),
-  });
-
-  return item;
-}
-
-Napi::Object InitThunkingManual(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  exports["createTestObject"] =
-      Napi::Function::New(env, CreateTestObject, "createTestObject");
-  return exports;
-}
+#include <napi.h>
+
+// The formulaic comment below should accompany any code that results in an
+// internal piece of heap data getting created, because each such piece of heap
+// data must be attached to an object by way of a deleter which gets called when
+// the object gets garbage-collected.
+//
+// At the very least, you can add a fprintf(stderr, ...) to the deleter in
+// napi-inl.h and then count the number of times the deleter prints by running
+// node --expose-gc test/thunking_manual.js and counting the number of prints
+// between the two rows of dashes. That number should coincide with the number
+// of formulaic comments below.
+//
+// Note that currently this result can only be achieved with node-chakracore,
+// because V8 does not garbage-collect classes.
+
+static Napi::Value TestMethod(const Napi::CallbackInfo& /*info*/) {
+  return Napi::Value();
+}
+
+static Napi::Value TestGetter(const Napi::CallbackInfo& /*info*/) {
+  return Napi::Value();
+}
+
+static void TestSetter(const Napi::CallbackInfo& /*info*/) {
+}
+
+class TestClass : public Napi::ObjectWrap<TestClass> {
+ public:
+  TestClass(const Napi::CallbackInfo& info):
+      ObjectWrap<TestClass>(info) {
+  }
+  static Napi::Value TestClassStaticMethod(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), 42);
+  }
+
+  static void TestClassStaticVoidMethod(const Napi::CallbackInfo& /*info*/) {
+  }
+
+  Napi::Value TestClassInstanceMethod(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), 42);
+  }
+
+  void TestClassInstanceVoidMethod(const Napi::CallbackInfo& /*info*/) {
+  }
+
+  Napi::Value TestClassInstanceGetter(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), 42);
+  }
+
+  void TestClassInstanceSetter(const Napi::CallbackInfo& /*info*/,
+                               const Napi::Value& /*new_value*/) {
+  }
+
+  static Napi::Function NewClass(Napi::Env env) {
+    return DefineClass(env, "TestClass", {
+      // Make sure to check that the deleter gets called.
+      StaticMethod("staticMethod", TestClassStaticMethod),
+      // Make sure to check that the deleter gets called.
+      StaticMethod("staticVoidMethod", TestClassStaticVoidMethod),
+      // Make sure to check that the deleter gets called.
+      StaticMethod(Napi::Symbol::New(env, "staticMethod"),
+                   TestClassStaticMethod),
+      // Make sure to check that the deleter gets called.
+      StaticMethod(Napi::Symbol::New(env, "staticVoidMethod"),
+                   TestClassStaticVoidMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceMethod("instanceMethod", &TestClass::TestClassInstanceMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceMethod("instanceVoidMethod",
+                     &TestClass::TestClassInstanceVoidMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceMethod(Napi::Symbol::New(env, "instanceMethod"),
+                     &TestClass::TestClassInstanceMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceMethod(Napi::Symbol::New(env, "instanceVoidMethod"),
+                     &TestClass::TestClassInstanceVoidMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceAccessor("instanceAccessor",
+                       &TestClass::TestClassInstanceGetter,
+                       &TestClass::TestClassInstanceSetter)
+    });
+  }
+};
+
+static Napi::Value CreateTestObject(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Object item = Napi::Object::New(env);
+
+  // Make sure to check that the deleter gets called.
+  item["testMethod"] = Napi::Function::New(env, TestMethod, "testMethod");
+
+  item.DefineProperties({
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       "accessor_1",
+                                       TestGetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       std::string("accessor_1_std_string"),
+                                       TestGetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       Napi::String::New(info.Env(),
+                                                        "accessor_1_js_string"),
+                                       TestGetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       "accessor_2",
+                                       TestGetter,
+                                       TestSetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       std::string("accessor_2_std_string"),
+                                       TestGetter,
+                                       TestSetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       Napi::String::New(env,
+                                                        "accessor_2_js_string"),
+                                       TestGetter,
+                                       TestSetter),
+    Napi::PropertyDescriptor::Value("TestClass", TestClass::NewClass(env)),
+  });
+
+  return item;
+}
+
+Napi::Object InitThunkingManual(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  exports["createTestObject"] =
+      Napi::Function::New(env, CreateTestObject, "createTestObject");
+  return exports;
+}

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

@@ -1,17 +1,17 @@
-// Flags: --expose-gc
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  console.log("Thunking: Performing initial GC");
-  global.gc();
-  console.log("Thunking: Creating test object");
-  let object = binding.thunking_manual.createTestObject();
-  object = null;
-  console.log("Thunking: About to GC\n--------");
-  global.gc();
-  console.log("--------\nThunking: GC complete");
-}
+// Flags: --expose-gc
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  console.log("Thunking: Performing initial GC");
+  global.gc();
+  console.log("Thunking: Creating test object");
+  let object = binding.thunking_manual.createTestObject();
+  object = null;
+  console.log("Thunking: About to GC\n--------");
+  global.gc();
+  console.log("--------\nThunking: GC complete");
+}