koffi 0.9.34 → 0.9.37

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

@@ -0,0 +1,217 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function assertPropertyIs(obj, key, attribute) {
+    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
+    assert.ok(propDesc);
+    assert.ok(propDesc[attribute]);
+  }
+
+  function assertPropertyIsNot(obj, key, attribute) {
+    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
+    assert.ok(propDesc);
+    assert.ok(!propDesc[attribute]);
+  }
+
+  function testDefineProperties(nameType) {
+    const obj = {};
+    binding.object.defineProperties(obj, nameType);
+
+    // accessors
+    assertPropertyIsNot(obj, 'readonlyAccessor', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessor', 'configurable');
+    assert.strictEqual(obj.readonlyAccessor, true);
+
+    assertPropertyIsNot(obj, 'readonlyAccessorWithUserData', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessorWithUserData', 'configurable');
+    assert.strictEqual(obj.readonlyAccessorWithUserData, 1234, nameType);
+
+    assertPropertyIsNot(obj, 'readwriteAccessor', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessor', 'configurable');
+    obj.readwriteAccessor = false;
+    assert.strictEqual(obj.readwriteAccessor, false);
+    obj.readwriteAccessor = true;
+    assert.strictEqual(obj.readwriteAccessor, true);
+
+    assertPropertyIsNot(obj, 'readwriteAccessorWithUserData', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessorWithUserData', 'configurable');
+    obj.readwriteAccessorWithUserData = 2;
+    assert.strictEqual(obj.readwriteAccessorWithUserData, 2);
+    obj.readwriteAccessorWithUserData = -14;
+    assert.strictEqual(obj.readwriteAccessorWithUserData, -14);
+
+    // templated accessors
+    assertPropertyIsNot(obj, 'readonlyAccessorT', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessorT', 'configurable');
+    assert.strictEqual(obj.readonlyAccessorT, true);
+
+    assertPropertyIsNot(obj, 'readonlyAccessorWithUserDataT', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessorWithUserDataT', 'configurable');
+    assert.strictEqual(obj.readonlyAccessorWithUserDataT, -14, nameType);
+
+    assertPropertyIsNot(obj, 'readwriteAccessorT', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessorT', 'configurable');
+    obj.readwriteAccessorT = false;
+    assert.strictEqual(obj.readwriteAccessorT, false);
+    obj.readwriteAccessorT = true;
+    assert.strictEqual(obj.readwriteAccessorT, true);
+
+    assertPropertyIsNot(obj, 'readwriteAccessorWithUserDataT', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessorWithUserDataT', 'configurable');
+    obj.readwriteAccessorWithUserDataT = 2;
+    assert.strictEqual(obj.readwriteAccessorWithUserDataT, 2);
+    obj.readwriteAccessorWithUserDataT = -14;
+    assert.strictEqual(obj.readwriteAccessorWithUserDataT, -14);
+
+    // values
+    assertPropertyIsNot(obj, 'readonlyValue', 'writable');
+    assertPropertyIsNot(obj, 'readonlyValue', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyValue', 'configurable');
+    assert.strictEqual(obj.readonlyValue, true);
+
+    assertPropertyIs(obj, 'readwriteValue', 'writable');
+    assertPropertyIsNot(obj, 'readwriteValue', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteValue', 'configurable');
+    obj.readwriteValue = false;
+    assert.strictEqual(obj.readwriteValue, false);
+    obj.readwriteValue = true;
+    assert.strictEqual(obj.readwriteValue, true);
+
+    assertPropertyIsNot(obj, 'enumerableValue', 'writable');
+    assertPropertyIs(obj, 'enumerableValue', 'enumerable');
+    assertPropertyIsNot(obj, 'enumerableValue', 'configurable');
+
+    assertPropertyIsNot(obj, 'configurableValue', 'writable');
+    assertPropertyIsNot(obj, 'configurableValue', 'enumerable');
+    assertPropertyIs(obj, 'configurableValue', 'configurable');
+
+    // functions
+    assertPropertyIsNot(obj, 'function', 'writable');
+    assertPropertyIsNot(obj, 'function', 'enumerable');
+    assertPropertyIsNot(obj, 'function', 'configurable');
+    assert.strictEqual(obj.function(), true);
+    assert.strictEqual(obj.functionWithUserData(), obj.readonlyAccessorWithUserDataT);
+  }
+
+  testDefineProperties('literal');
+  testDefineProperties('string');
+  testDefineProperties('value');
+
+  {
+    assert.strictEqual(binding.object.emptyConstructor(true), true);
+    assert.strictEqual(binding.object.emptyConstructor(false), false);
+  }
+
+  {
+    const expected = { 'one': 1, 'two': 2, 'three': 3 };
+    const actual = binding.object.constructorFromObject(expected);
+    assert.deepStrictEqual(actual, expected);
+  }
+
+  {
+    const obj = {};
+    const testSym = Symbol();
+    binding.object.defineValueProperty(obj, testSym, 1);
+    assert.strictEqual(obj[testSym], 1);
+  }
+
+  {
+    const testSym = Symbol();
+    const obj = { 'one': 1, 'two': 2, 'three': 3, [testSym]: 4 };
+    var arr = binding.object.GetPropertyNames(obj);
+    assert.deepStrictEqual(arr, ['one', 'two', 'three']);
+  }
+
+  {
+    const magicObject = binding.object.createObjectUsingMagic();
+    assert.deepStrictEqual(magicObject, {
+      0: 0,
+      42: 120,
+      cp_false: false,
+      cp_true: true,
+      s_true: true,
+      s_false: false,
+      '0.0f': 0,
+      '0.0': 0,
+      '-1': -1,
+      foo2: 'foo',
+      foo4: 'foo',
+      foo5: 'foo',
+      foo6: 'foo',
+      foo7: 'foo',
+      circular: magicObject,
+      circular2: magicObject
+    });
+  }
+
+  {
+    function Ctor() {};
+
+    assert.strictEqual(binding.object.instanceOf(new Ctor(), Ctor), true);
+    assert.strictEqual(binding.object.instanceOf(new Ctor(), Object), true);
+    assert.strictEqual(binding.object.instanceOf({}, Ctor), false);
+    assert.strictEqual(binding.object.instanceOf(null, Ctor), false);
+  }
+
+  if ('sum' in binding.object) {
+      {
+        const obj = {
+          '-forbid': -0x4B1D,
+          '-feedcode': -0xFEEDC0DE,
+          '+office': +0x0FF1CE,
+          '+forbid': +0x4B1D,
+          '+deadbeef': +0xDEADBEEF,
+          '+feedcode': +0xFEEDC0DE,
+        };
+
+        let sum = 0;
+        for (const key in obj) {
+          sum += obj[key];
+        }
+
+        assert.strictEqual(binding.object.sum(obj), sum);
+      }
+
+      {
+        const obj = new Proxy({
+          '-forbid': -0x4B1D,
+          '-feedcode': -0xFEEDC0DE,
+          '+office': +0x0FF1CE,
+          '+forbid': +0x4B1D,
+          '+deadbeef': +0xDEADBEEF,
+          '+feedcode': +0xFEEDC0DE,
+        }, {
+          getOwnPropertyDescriptor(target, p) {
+            throw new Error("getOwnPropertyDescriptor error");
+          },
+          ownKeys(target) {
+            throw new Error("ownKeys error");
+          },
+        });
+
+        assert.throws(() => {
+          binding.object.sum(obj);
+        }, /ownKeys error/);
+    }
+  }
+
+  if ('increment' in binding.object) {
+    const obj = {
+      'a': 0,
+      'b': 1,
+      'c': 2,
+    };
+
+    binding.object.increment(obj);
+
+    assert.deepStrictEqual(obj, {
+      'a': 1,
+      'b': 2,
+      'c': 3,
+    });
+  }
+}

package/vendor/node-addon-api/test/object/object_deprecated.cc

@@ -0,0 +1,66 @@
+#include "napi.h"
+
+using namespace Napi;
+
+static bool testValue = true;
+
+namespace {
+
+Value TestGetter(const CallbackInfo& info) {
+   return Boolean::New(info.Env(), testValue);
+}
+
+void TestSetter(const CallbackInfo& info) {
+   testValue = info[0].As<Boolean>();
+}
+
+Value TestFunction(const CallbackInfo& info) {
+   return Boolean::New(info.Env(), true);
+}
+
+void DefineProperties(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String nameType = info[1].As<String>();
+  Env env = info.Env();
+
+  if (nameType.Utf8Value() == "literal") {
+    obj.DefineProperties({
+      PropertyDescriptor::Accessor("readonlyAccessor", TestGetter),
+      PropertyDescriptor::Accessor("readwriteAccessor", TestGetter, TestSetter),
+      PropertyDescriptor::Function("function", TestFunction),
+    });
+  } else if (nameType.Utf8Value() == "string") {
+    // VS2013 has lifetime issues when passing temporary objects into the constructor of another
+    // object. It generates code to destruct the object as soon as the constructor call returns.
+    // Since this isn't a common case for using std::string objects, I'm refactoring the test to
+    // work around the issue.
+    std::string str1("readonlyAccessor");
+    std::string str2("readwriteAccessor");
+    std::string str7("function");
+
+    obj.DefineProperties({
+      PropertyDescriptor::Accessor(str1, TestGetter),
+      PropertyDescriptor::Accessor(str2, TestGetter, TestSetter),
+      PropertyDescriptor::Function(str7, TestFunction),
+    });
+  } else if (nameType.Utf8Value() == "value") {
+    obj.DefineProperties({
+      PropertyDescriptor::Accessor(
+        Napi::String::New(env, "readonlyAccessor"), TestGetter),
+      PropertyDescriptor::Accessor(
+        Napi::String::New(env, "readwriteAccessor"), TestGetter, TestSetter),
+      PropertyDescriptor::Function(
+        Napi::String::New(env, "function"), TestFunction),
+    });
+  }
+}
+
+} // end of anonymous namespace
+
+Object InitObjectDeprecated(Env env) {
+  Object exports = Object::New(env);
+
+  exports["defineProperties"] = Function::New(env, DefineProperties);
+
+  return exports;
+}

package/vendor/node-addon-api/test/object/object_deprecated.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  if (!('object_deprecated' in binding)) {
+    return;
+  }
+  function assertPropertyIs(obj, key, attribute) {
+    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
+    assert.ok(propDesc);
+    assert.ok(propDesc[attribute]);
+  }
+
+  function assertPropertyIsNot(obj, key, attribute) {
+    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
+    assert.ok(propDesc);
+    assert.ok(!propDesc[attribute]);
+  }
+
+  function testDefineProperties(nameType) {
+    const obj = {};
+    binding.object.defineProperties(obj, nameType);
+
+    assertPropertyIsNot(obj, 'readonlyAccessor', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessor', 'configurable');
+    assert.strictEqual(obj.readonlyAccessor, true);
+
+    assertPropertyIsNot(obj, 'readwriteAccessor', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessor', 'configurable');
+    obj.readwriteAccessor = false;
+    assert.strictEqual(obj.readwriteAccessor, false);
+    obj.readwriteAccessor = true;
+    assert.strictEqual(obj.readwriteAccessor, true);
+
+    assertPropertyIsNot(obj, 'function', 'writable');
+    assertPropertyIsNot(obj, 'function', 'enumerable');
+    assertPropertyIsNot(obj, 'function', 'configurable');
+    assert.strictEqual(obj.function(), true);
+  }
+
+  testDefineProperties('literal');
+  testDefineProperties('string');
+  testDefineProperties('value');
+}

package/vendor/node-addon-api/test/object/object_freeze_seal.cc

@@ -0,0 +1,25 @@
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 7)
+
+using namespace Napi;
+
+Value Freeze(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Freeze(), false));
+}
+
+Value Seal(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Seal(), false));
+}
+
+Object InitObjectFreezeSeal(Env env) {
+  Object exports = Object::New(env);
+  exports["freeze"] = Function::New(env, Freeze);
+  exports["seal"] = Function::New(env, Seal);
+  return exports;
+}
+
+#endif

package/vendor/node-addon-api/test/object/object_freeze_seal.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+    {
+        const obj = { x: 'a', y: 'b', z: 'c' };
+        assert.strictEqual(binding.object_freeze_seal.freeze(obj), true);
+        assert.strictEqual(Object.isFrozen(obj), true);
+        assert.throws(() => {
+          obj.x = 10;
+        }, /Cannot assign to read only property 'x' of object '#<Object>/);
+        assert.throws(() => {
+          obj.w = 15;
+        }, /Cannot add property w, object is not extensible/);
+        assert.throws(() => {
+          delete obj.x;
+        }, /Cannot delete property 'x' of #<Object>/);
+    }
+
+    {
+        const obj = new Proxy({ x: 'a', y: 'b', z: 'c' }, {
+          preventExtensions() {
+            throw new Error('foo');
+          },
+        });
+
+        assert.throws(() => {
+          binding.object_freeze_seal.freeze(obj);
+        }, /foo/);
+    }
+
+    {
+        const obj = { x: 'a', y: 'b', z: 'c' };
+        assert.strictEqual(binding.object_freeze_seal.seal(obj), true);
+        assert.strictEqual(Object.isSealed(obj), true);
+        assert.throws(() => {
+          obj.w = 'd';
+        }, /Cannot add property w, object is not extensible/);
+        assert.throws(() => {
+          delete obj.x;
+        }, /Cannot delete property 'x' of #<Object>/);
+        // Sealed objects allow updating existing properties,
+        // so this should not throw.
+        obj.x = 'd';
+    }
+
+    {
+        const obj = new Proxy({ x: 'a', y: 'b', z: 'c' }, {
+          preventExtensions() {
+            throw new Error('foo');
+          },
+        });
+
+        assert.throws(() => {
+          binding.object_freeze_seal.seal(obj);
+        }, /foo/);
+    }
+}

package/vendor/node-addon-api/test/object/set_property.cc

@@ -0,0 +1,45 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value SetPropertyWithNapiValue(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Name key = info[1].As<Name>();
+  Value value = info[2];
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(obj.Set(static_cast<napi_value>(key), value), false));
+}
+
+Value SetPropertyWithNapiWrapperValue(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Name key = info[1].As<Name>();
+  Value value = info[2];
+  return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Set(key, value), false));
+}
+
+Value SetPropertyWithUint32(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Number key = info[1].As<Number>();
+  Value value = info[2];
+  return Boolean::New(info.Env(),
+                      MaybeUnwrapOr(obj.Set(key.Uint32Value(), value), false));
+}
+
+Value SetPropertyWithCStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  Value value = info[2];
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(obj.Set(jsKey.Utf8Value().c_str(), value), false));
+}
+
+Value SetPropertyWithCppStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  Value value = info[2];
+  return Boolean::New(info.Env(),
+                      MaybeUnwrapOr(obj.Set(jsKey.Utf8Value(), value), false));
+}

package/vendor/node-addon-api/test/object/set_property.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test (binding) {
+  function testSetProperty (nativeSetProperty, key = 'test') {
+    const obj = {};
+    assert.strictEqual(nativeSetProperty(obj, key, 1), true);
+    assert.strictEqual(obj[key], 1);
+  }
+
+  function testShouldThrowErrorIfKeyIsInvalid (nativeSetProperty) {
+    assert.throws(() => {
+      nativeSetProperty(undefined, 'test', 1);
+    }, /Cannot convert undefined or null to object/);
+  }
+
+  testSetProperty(binding.object.setPropertyWithNapiValue);
+  testSetProperty(binding.object.setPropertyWithNapiWrapperValue);
+  testSetProperty(binding.object.setPropertyWithCStyleString);
+  testSetProperty(binding.object.setPropertyWithCppStyleString);
+  testSetProperty(binding.object.setPropertyWithUint32, 12);
+
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.setPropertyWithNapiValue);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.setPropertyWithNapiWrapperValue);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.setPropertyWithCStyleString);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.setPropertyWithCppStyleString);
+}

package/vendor/node-addon-api/test/object/subscript_operator.cc

@@ -0,0 +1,58 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value SubscriptGetWithCStyleString(const CallbackInfo& info) {
+  String jsKey = info[1].As<String>();
+
+  // make sure const case compiles
+  const Object obj2 = info[0].As<Object>();
+  MaybeUnwrap(obj2[jsKey.Utf8Value().c_str()]).As<Boolean>();
+
+  Object obj = info[0].As<Object>();
+  return obj[jsKey.Utf8Value().c_str()];
+}
+
+Value SubscriptGetWithCppStyleString(const CallbackInfo& info) {
+  String jsKey = info[1].As<String>();
+
+  // make sure const case compiles
+  const Object obj2 = info[0].As<Object>();
+  MaybeUnwrap(obj2[jsKey.Utf8Value()]).As<Boolean>();
+
+  Object obj = info[0].As<Object>();
+  return obj[jsKey.Utf8Value()];
+}
+
+Value SubscriptGetAtIndex(const CallbackInfo& info) {
+  uint32_t index = info[1].As<Napi::Number>();
+
+  // make sure const case compiles
+  const Object obj2 = info[0].As<Object>();
+  MaybeUnwrap(obj2[index]).As<Boolean>();
+
+  Object obj = info[0].As<Object>();
+  return obj[index];
+}
+
+void SubscriptSetWithCStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  Value value = info[2];
+  obj[jsKey.Utf8Value().c_str()] = value;
+}
+
+void SubscriptSetWithCppStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  Value value = info[2];
+  obj[jsKey.Utf8Value()] = value;
+}
+
+void SubscriptSetAtIndex(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  uint32_t index = info[1].As<Napi::Number>();
+  Value value = info[2];
+  obj[index] = value;
+}

package/vendor/node-addon-api/test/object/subscript_operator.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function testProperty(obj, key, value, nativeGetProperty, nativeSetProperty) {
+    nativeSetProperty(obj, key, value);
+    assert.strictEqual(nativeGetProperty(obj, key), value);
+  }
+
+  testProperty({}, 'key', 'value', binding.object.subscriptGetWithCStyleString, binding.object.subscriptSetWithCStyleString);
+  testProperty({ key: 'override me' }, 'key', 'value', binding.object.subscriptGetWithCppStyleString, binding.object.subscriptSetWithCppStyleString);
+  testProperty({}, 0, 'value', binding.object.subscriptGetAtIndex, binding.object.subscriptSetAtIndex);
+  testProperty({ key: 'override me' }, 0, 'value', binding.object.subscriptGetAtIndex, binding.object.subscriptSetAtIndex);
+}