koffi 0.9.33 → 0.9.34

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

@@ -1,217 +0,0 @@
-'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

@@ -1,66 +0,0 @@
-#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

@@ -1,47 +0,0 @@
-'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

@@ -1,25 +0,0 @@
-#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

@@ -1,61 +0,0 @@
-'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

@@ -1,45 +0,0 @@
-#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

@@ -1,30 +0,0 @@
-'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

@@ -1,58 +0,0 @@
-#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

@@ -1,17 +0,0 @@
-'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);
-}