koffi 0.9.2 → 0.9.5

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

@@ -1,45 +1,45 @@
-'use strict';
-
-const assert = require('assert');
-const testUtil = require('./testUtil');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  return testUtil.runGCTests([
-    'Plain C string',
-    () => {
-      const sum = binding.run_script.plainString();
-      assert.strictEqual(sum, 1 + 2 + 3);
-    },
-
-    'std::string',
-    () => {
-      const sum = binding.run_script.stdString();
-      assert.strictEqual(sum, 1 + 2 + 3);
-    },
-
-    'JavaScript string',
-    () => {
-      const sum = binding.run_script.jsString('1 + 2 + 3');
-      assert.strictEqual(sum, 1 + 2 + 3);
-    },
-
-    'JavaScript, but not a string',
-    () => {
-      assert.throws(() => {
-        binding.run_script.jsString(true);
-      }, {
-        name: 'TypeError',
-        message: 'A string was expected'
-      });
-    },
-
-    'With context',
-    () => {
-      const a = 1; const b = 2; const c = 3;
-      const sum = binding.run_script.withContext('a + b + c', { a, b, c });
-      assert.strictEqual(sum, a + b + c);
-    }
-  ]);
-}
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTest(test);
+
+function test (binding) {
+  return testUtil.runGCTests([
+    'Plain C string',
+    () => {
+      const sum = binding.run_script.plainString();
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'std::string',
+    () => {
+      const sum = binding.run_script.stdString();
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'JavaScript string',
+    () => {
+      const sum = binding.run_script.jsString('1 + 2 + 3');
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'JavaScript, but not a string',
+    () => {
+      assert.throws(() => {
+        binding.run_script.jsString(true);
+      }, {
+        name: 'TypeError',
+        message: 'A string was expected'
+      });
+    },
+
+    'With context',
+    () => {
+      const a = 1; const b = 2; const c = 3;
+      const sum = binding.run_script.withContext('a + b + c', { a, b, c });
+      assert.strictEqual(sum, a + b + c);
+    }
+  ]);
+}

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

@@ -1,79 +1,79 @@
-#include <napi.h>
-#include "test_helper.h"
-using namespace Napi;
-
-Symbol CreateNewSymbolWithNoArgs(const Napi::CallbackInfo&) {
-  return Napi::Symbol();
-}
-
-Symbol CreateNewSymbolWithCppStrDesc(const Napi::CallbackInfo& info) {
-  String cppStrKey = info[0].As<String>();
-  return Napi::Symbol::New(info.Env(), cppStrKey.Utf8Value());
-}
-
-Symbol CreateNewSymbolWithCStrDesc(const Napi::CallbackInfo& info) {
-  String cStrKey = info[0].As<String>();
-  return Napi::Symbol::New(info.Env(), cStrKey.Utf8Value().c_str());
-}
-
-Symbol CreateNewSymbolWithNapiString(const Napi::CallbackInfo& info) {
-  String strKey = info[0].As<String>();
-  return Napi::Symbol::New(info.Env(), strKey);
-}
-
-Symbol GetWellknownSymbol(const Napi::CallbackInfo& info) {
-  String registrySymbol = info[0].As<String>();
-  return MaybeUnwrap(
-      Napi::Symbol::WellKnown(info.Env(), registrySymbol.Utf8Value().c_str()));
-}
-
-Symbol FetchSymbolFromGlobalRegistry(const Napi::CallbackInfo& info) {
-  String registrySymbol = info[0].As<String>();
-  return MaybeUnwrap(Napi::Symbol::For(info.Env(), registrySymbol));
-}
-
-Symbol FetchSymbolFromGlobalRegistryWithCppKey(const Napi::CallbackInfo& info) {
-  String cppStringKey = info[0].As<String>();
-  return MaybeUnwrap(Napi::Symbol::For(info.Env(), cppStringKey.Utf8Value()));
-}
-
-Symbol FetchSymbolFromGlobalRegistryWithCKey(const Napi::CallbackInfo& info) {
-  String cppStringKey = info[0].As<String>();
-  return MaybeUnwrap(
-      Napi::Symbol::For(info.Env(), cppStringKey.Utf8Value().c_str()));
-}
-
-Symbol TestUndefinedSymbolsCanBeCreated(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  return MaybeUnwrap(Napi::Symbol::For(env, env.Undefined()));
-}
-
-Symbol TestNullSymbolsCanBeCreated(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  return MaybeUnwrap(Napi::Symbol::For(env, env.Null()));
-}
-
-Object InitSymbol(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createNewSymbolWithNoArgs"] =
-      Function::New(env, CreateNewSymbolWithNoArgs);
-  exports["createNewSymbolWithCppStr"] =
-      Function::New(env, CreateNewSymbolWithCppStrDesc);
-  exports["createNewSymbolWithCStr"] =
-      Function::New(env, CreateNewSymbolWithCStrDesc);
-  exports["createNewSymbolWithNapi"] =
-      Function::New(env, CreateNewSymbolWithNapiString);
-  exports["getWellKnownSymbol"] = Function::New(env, GetWellknownSymbol);
-  exports["getSymbolFromGlobalRegistry"] =
-      Function::New(env, FetchSymbolFromGlobalRegistry);
-  exports["getSymbolFromGlobalRegistryWithCKey"] =
-      Function::New(env, FetchSymbolFromGlobalRegistryWithCKey);
-  exports["getSymbolFromGlobalRegistryWithCppKey"] =
-      Function::New(env, FetchSymbolFromGlobalRegistryWithCppKey);
-  exports["testUndefinedSymbolCanBeCreated"] =
-      Function::New(env, TestUndefinedSymbolsCanBeCreated);
-  exports["testNullSymbolCanBeCreated"] =
-      Function::New(env, TestNullSymbolsCanBeCreated);
-  return exports;
-}
+#include <napi.h>
+#include "test_helper.h"
+using namespace Napi;
+
+Symbol CreateNewSymbolWithNoArgs(const Napi::CallbackInfo&) {
+  return Napi::Symbol();
+}
+
+Symbol CreateNewSymbolWithCppStrDesc(const Napi::CallbackInfo& info) {
+  String cppStrKey = info[0].As<String>();
+  return Napi::Symbol::New(info.Env(), cppStrKey.Utf8Value());
+}
+
+Symbol CreateNewSymbolWithCStrDesc(const Napi::CallbackInfo& info) {
+  String cStrKey = info[0].As<String>();
+  return Napi::Symbol::New(info.Env(), cStrKey.Utf8Value().c_str());
+}
+
+Symbol CreateNewSymbolWithNapiString(const Napi::CallbackInfo& info) {
+  String strKey = info[0].As<String>();
+  return Napi::Symbol::New(info.Env(), strKey);
+}
+
+Symbol GetWellknownSymbol(const Napi::CallbackInfo& info) {
+  String registrySymbol = info[0].As<String>();
+  return MaybeUnwrap(
+      Napi::Symbol::WellKnown(info.Env(), registrySymbol.Utf8Value().c_str()));
+}
+
+Symbol FetchSymbolFromGlobalRegistry(const Napi::CallbackInfo& info) {
+  String registrySymbol = info[0].As<String>();
+  return MaybeUnwrap(Napi::Symbol::For(info.Env(), registrySymbol));
+}
+
+Symbol FetchSymbolFromGlobalRegistryWithCppKey(const Napi::CallbackInfo& info) {
+  String cppStringKey = info[0].As<String>();
+  return MaybeUnwrap(Napi::Symbol::For(info.Env(), cppStringKey.Utf8Value()));
+}
+
+Symbol FetchSymbolFromGlobalRegistryWithCKey(const Napi::CallbackInfo& info) {
+  String cppStringKey = info[0].As<String>();
+  return MaybeUnwrap(
+      Napi::Symbol::For(info.Env(), cppStringKey.Utf8Value().c_str()));
+}
+
+Symbol TestUndefinedSymbolsCanBeCreated(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return MaybeUnwrap(Napi::Symbol::For(env, env.Undefined()));
+}
+
+Symbol TestNullSymbolsCanBeCreated(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return MaybeUnwrap(Napi::Symbol::For(env, env.Null()));
+}
+
+Object InitSymbol(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createNewSymbolWithNoArgs"] =
+      Function::New(env, CreateNewSymbolWithNoArgs);
+  exports["createNewSymbolWithCppStr"] =
+      Function::New(env, CreateNewSymbolWithCppStrDesc);
+  exports["createNewSymbolWithCStr"] =
+      Function::New(env, CreateNewSymbolWithCStrDesc);
+  exports["createNewSymbolWithNapi"] =
+      Function::New(env, CreateNewSymbolWithNapiString);
+  exports["getWellKnownSymbol"] = Function::New(env, GetWellknownSymbol);
+  exports["getSymbolFromGlobalRegistry"] =
+      Function::New(env, FetchSymbolFromGlobalRegistry);
+  exports["getSymbolFromGlobalRegistryWithCKey"] =
+      Function::New(env, FetchSymbolFromGlobalRegistryWithCKey);
+  exports["getSymbolFromGlobalRegistryWithCppKey"] =
+      Function::New(env, FetchSymbolFromGlobalRegistryWithCppKey);
+  exports["testUndefinedSymbolCanBeCreated"] =
+      Function::New(env, TestUndefinedSymbolsCanBeCreated);
+  exports["testNullSymbolCanBeCreated"] =
+      Function::New(env, TestNullSymbolsCanBeCreated);
+  return exports;
+}

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

@@ -1,73 +1,73 @@
-'use strict';
-
-const buildType = process.config.target_defaults.default_configuration;
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-
-function test(binding)
-{
-    const majorNodeVersion = process.versions.node.split('.')[0];
-
-    let wellKnownSymbolFunctions = ['asyncIterator','hasInstance','isConcatSpreadable', 'iterator','match','replace','search','split','species','toPrimitive','toStringTag','unscopables'];
-    if (majorNodeVersion >= 12) {
-      wellKnownSymbolFunctions.push('matchAll');
-    }
-
-    function assertCanCreateSymbol(symbol)
-    {
-      assert(binding.symbol.createNewSymbolWithCppStr(symbol) !== null);
-      assert(binding.symbol.createNewSymbolWithCStr(symbol) !== null);
-      assert(binding.symbol.createNewSymbolWithNapi(symbol) !== null);
-    }
-
-    function assertSymbolAreUnique(symbol)
-    {
-        const symbolOne = binding.symbol.createNewSymbolWithCppStr(symbol);
-        const symbolTwo = binding.symbol.createNewSymbolWithCppStr(symbol);
-
-        assert(symbolOne !== symbolTwo);
-    }
-
-    function assertSymbolIsWellknown(symbol)
-    {
-      const symbOne = binding.symbol.getWellKnownSymbol(symbol);
-      const symbTwo = binding.symbol.getWellKnownSymbol(symbol);
-      assert(symbOne && symbTwo);
-      assert(symbOne === symbTwo);
-    }
-
-    function assertSymbolIsNotWellknown(symbol)
-    {
-      const symbolTest = binding.symbol.getWellKnownSymbol(symbol);
-      assert(symbolTest === undefined);
-    }
-
-    function assertCanCreateOrFetchGlobalSymbols(symbol, fetchFunction)
-    {
-      const symbOne = fetchFunction(symbol);
-      const symbTwo = fetchFunction(symbol);
-      assert(symbOne && symbTwo);
-      assert(symbOne === symbTwo);
-    }
-
-    assertCanCreateSymbol("testing");
-    assertSymbolAreUnique("symbol");
-    assertSymbolIsNotWellknown("testing");
-
-     for(const wellknownProperty of wellKnownSymbolFunctions)
-     {
-       assertSymbolIsWellknown(wellknownProperty);
-     }
-
-     assertCanCreateOrFetchGlobalSymbols("data", binding.symbol.getSymbolFromGlobalRegistry);
-     assertCanCreateOrFetchGlobalSymbols("CppKey", binding.symbol.getSymbolFromGlobalRegistryWithCppKey);
-     assertCanCreateOrFetchGlobalSymbols("CKey", binding.symbol.getSymbolFromGlobalRegistryWithCKey);
-
-    assert(binding.symbol.createNewSymbolWithNoArgs() === undefined);
-
-    assert(binding.symbol.testNullSymbolCanBeCreated() === binding.symbol.testNullSymbolCanBeCreated());
-    assert(binding.symbol.testUndefinedSymbolCanBeCreated() === binding.symbol.testUndefinedSymbolCanBeCreated());
-    assert(binding.symbol.testUndefinedSymbolCanBeCreated() !== binding.symbol.testNullSymbolCanBeCreated());
-}
+'use strict';
+
+const buildType = process.config.target_defaults.default_configuration;
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+
+function test(binding)
+{
+    const majorNodeVersion = process.versions.node.split('.')[0];
+
+    let wellKnownSymbolFunctions = ['asyncIterator','hasInstance','isConcatSpreadable', 'iterator','match','replace','search','split','species','toPrimitive','toStringTag','unscopables'];
+    if (majorNodeVersion >= 12) {
+      wellKnownSymbolFunctions.push('matchAll');
+    }
+
+    function assertCanCreateSymbol(symbol)
+    {
+      assert(binding.symbol.createNewSymbolWithCppStr(symbol) !== null);
+      assert(binding.symbol.createNewSymbolWithCStr(symbol) !== null);
+      assert(binding.symbol.createNewSymbolWithNapi(symbol) !== null);
+    }
+
+    function assertSymbolAreUnique(symbol)
+    {
+        const symbolOne = binding.symbol.createNewSymbolWithCppStr(symbol);
+        const symbolTwo = binding.symbol.createNewSymbolWithCppStr(symbol);
+
+        assert(symbolOne !== symbolTwo);
+    }
+
+    function assertSymbolIsWellknown(symbol)
+    {
+      const symbOne = binding.symbol.getWellKnownSymbol(symbol);
+      const symbTwo = binding.symbol.getWellKnownSymbol(symbol);
+      assert(symbOne && symbTwo);
+      assert(symbOne === symbTwo);
+    }
+
+    function assertSymbolIsNotWellknown(symbol)
+    {
+      const symbolTest = binding.symbol.getWellKnownSymbol(symbol);
+      assert(symbolTest === undefined);
+    }
+
+    function assertCanCreateOrFetchGlobalSymbols(symbol, fetchFunction)
+    {
+      const symbOne = fetchFunction(symbol);
+      const symbTwo = fetchFunction(symbol);
+      assert(symbOne && symbTwo);
+      assert(symbOne === symbTwo);
+    }
+
+    assertCanCreateSymbol("testing");
+    assertSymbolAreUnique("symbol");
+    assertSymbolIsNotWellknown("testing");
+
+     for(const wellknownProperty of wellKnownSymbolFunctions)
+     {
+       assertSymbolIsWellknown(wellknownProperty);
+     }
+
+     assertCanCreateOrFetchGlobalSymbols("data", binding.symbol.getSymbolFromGlobalRegistry);
+     assertCanCreateOrFetchGlobalSymbols("CppKey", binding.symbol.getSymbolFromGlobalRegistryWithCppKey);
+     assertCanCreateOrFetchGlobalSymbols("CKey", binding.symbol.getSymbolFromGlobalRegistryWithCKey);
+
+    assert(binding.symbol.createNewSymbolWithNoArgs() === undefined);
+
+    assert(binding.symbol.testNullSymbolCanBeCreated() === binding.symbol.testNullSymbolCanBeCreated());
+    assert(binding.symbol.testUndefinedSymbolCanBeCreated() === binding.symbol.testUndefinedSymbolCanBeCreated());
+    assert(binding.symbol.testUndefinedSymbolCanBeCreated() !== binding.symbol.testNullSymbolCanBeCreated());
+}

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

@@ -1,54 +1,54 @@
-// Run each test function in sequence,
-// with an async delay and GC call between each.
-
-function tick(x) {
-  return new Promise((resolve) => {
-    setImmediate(function ontick() {
-      if (--x === 0) {
-        resolve();
-      } else {
-        setImmediate(ontick);
-      }
-    });
-  });
-};
-
-async function runGCTests(tests) {
-  // Break up test list into a list of lists of the form
-  // [ [ 'test name', function() {}, ... ], ..., ].
-  const testList = [];
-  let currentTest;
-  for (const item of tests) {
-    if (typeof item === 'string') {
-      currentTest = [];
-      testList.push(currentTest);
-    }
-    currentTest.push(item);
-  }
-
-  for (const test of testList) {
-    await (async function(test) {
-      let title;
-      for (let i = 0; i < test.length; i++) {
-        if (i === 0) {
-          title = test[i];
-        } else {
-          try {
-            test[i]();
-          } catch (e) {
-            console.error('Test failed: ' + title);
-            throw e;
-          }
-          if (i < tests.length - 1) {
-            global.gc();
-            await tick(10);
-          }
-        }
-      }
-    })(test);
-  }
-}
-
-module.exports = {
-  runGCTests,
-};
+// Run each test function in sequence,
+// with an async delay and GC call between each.
+
+function tick(x) {
+  return new Promise((resolve) => {
+    setImmediate(function ontick() {
+      if (--x === 0) {
+        resolve();
+      } else {
+        setImmediate(ontick);
+      }
+    });
+  });
+};
+
+async function runGCTests(tests) {
+  // Break up test list into a list of lists of the form
+  // [ [ 'test name', function() {}, ... ], ..., ].
+  const testList = [];
+  let currentTest;
+  for (const item of tests) {
+    if (typeof item === 'string') {
+      currentTest = [];
+      testList.push(currentTest);
+    }
+    currentTest.push(item);
+  }
+
+  for (const test of testList) {
+    await (async function(test) {
+      let title;
+      for (let i = 0; i < test.length; i++) {
+        if (i === 0) {
+          title = test[i];
+        } else {
+          try {
+            test[i]();
+          } catch (e) {
+            console.error('Test failed: ' + title);
+            throw e;
+          }
+          if (i < tests.length - 1) {
+            global.gc();
+            await tick(10);
+          }
+        }
+      }
+    })(test);
+  }
+}
+
+module.exports = {
+  runGCTests,
+};