koffi 2.16.0-beta.2 → 2.16.0

package/vendor/node-addon-api/test/basic_types/array.cc

@@ -1,40 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-Value CreateArray(const CallbackInfo& info) {
-  if (info.Length() > 0) {
-    size_t length = info[0].As<Number>().Uint32Value();
-    return Array::New(info.Env(), length);
-  } else {
-    return Array::New(info.Env());
-  }
-}
-
-Value GetLength(const CallbackInfo& info) {
-  Array array = info[0].As<Array>();
-  return Number::New(info.Env(), static_cast<uint32_t>(array.Length()));
-}
-
-Value GetElement(const CallbackInfo& info) {
-  Array array = info[0].As<Array>();
-  size_t index = info[1].As<Number>().Uint32Value();
-  return array[index];
-}
-
-void SetElement(const CallbackInfo& info) {
-  Array array = info[0].As<Array>();
-  size_t index = info[1].As<Number>().Uint32Value();
-  array[index] = info[2].As<Value>();
-}
-
-Object InitBasicTypesArray(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createArray"] = Function::New(env, CreateArray);
-  exports["getLength"] = Function::New(env, GetLength);
-  exports["get"] = Function::New(env, GetElement);
-  exports["set"] = Function::New(env, SetElement);
-
-  return exports;
-}

package/vendor/node-addon-api/test/basic_types/array.js

@@ -1,34 +0,0 @@
-'use strict';
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test (binding) {
-  // create empty array
-  const array = binding.basic_types_array.createArray();
-  assert.strictEqual(binding.basic_types_array.getLength(array), 0);
-
-  // create array with length
-  const arrayWithLength = binding.basic_types_array.createArray(10);
-  assert.strictEqual(binding.basic_types_array.getLength(arrayWithLength), 10);
-
-  // set function test
-  binding.basic_types_array.set(array, 0, 10);
-  binding.basic_types_array.set(array, 1, 'test');
-  binding.basic_types_array.set(array, 2, 3.0);
-
-  // check length after set data
-  assert.strictEqual(binding.basic_types_array.getLength(array), 3);
-
-  // get function test
-  assert.strictEqual(binding.basic_types_array.get(array, 0), 10);
-  assert.strictEqual(binding.basic_types_array.get(array, 1), 'test');
-  assert.strictEqual(binding.basic_types_array.get(array, 2), 3.0);
-
-  // overwrite test
-  binding.basic_types_array.set(array, 0, 5);
-  assert.strictEqual(binding.basic_types_array.get(array, 0), 5);
-
-  // out of index test
-  assert.strictEqual(binding.basic_types_array.get(array, 5), undefined);
-}

package/vendor/node-addon-api/test/basic_types/boolean.cc

@@ -1,40 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-Value CreateBoolean(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].As<Boolean>().Value());
-}
-
-Value CreateEmptyBoolean(const CallbackInfo& info) {
-  Boolean* boolean = new Boolean();
-  return Boolean::New(info.Env(), boolean->IsEmpty());
-}
-
-Value CreateBooleanFromExistingValue(const CallbackInfo& info) {
-  Boolean boolean(info.Env(), info[0].As<Boolean>());
-  return Boolean::New(info.Env(), boolean.Value());
-}
-
-Value CreateBooleanFromPrimitive(const CallbackInfo& info) {
-  bool boolean = info[0].As<Boolean>();
-  return Boolean::New(info.Env(), boolean);
-}
-
-Value OperatorBool(const CallbackInfo& info) {
-  Boolean boolean(info.Env(), info[0].As<Boolean>());
-  return Boolean::New(info.Env(), static_cast<bool>(boolean));
-}
-
-Object InitBasicTypesBoolean(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createBoolean"] = Function::New(env, CreateBoolean);
-  exports["createEmptyBoolean"] = Function::New(env, CreateEmptyBoolean);
-  exports["createBooleanFromExistingValue"] =
-      Function::New(env, CreateBooleanFromExistingValue);
-  exports["createBooleanFromPrimitive"] =
-      Function::New(env, CreateBooleanFromPrimitive);
-  exports["operatorBool"] = Function::New(env, OperatorBool);
-  return exports;
-}

package/vendor/node-addon-api/test/basic_types/boolean.js

@@ -1,34 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test (binding) {
-  const bool1 = binding.basic_types_boolean.createBoolean(true);
-  assert.strictEqual(bool1, true);
-
-  const bool2 = binding.basic_types_boolean.createBoolean(false);
-  assert.strictEqual(bool2, false);
-
-  const emptyBoolean = binding.basic_types_boolean.createEmptyBoolean();
-  assert.strictEqual(emptyBoolean, true);
-
-  const bool3 = binding.basic_types_boolean.createBooleanFromExistingValue(true);
-  assert.strictEqual(bool3, true);
-
-  const bool4 = binding.basic_types_boolean.createBooleanFromExistingValue(false);
-  assert.strictEqual(bool4, false);
-
-  const bool5 = binding.basic_types_boolean.createBooleanFromPrimitive(true);
-  assert.strictEqual(bool5, true);
-
-  const bool6 = binding.basic_types_boolean.createBooleanFromPrimitive(false);
-  assert.strictEqual(bool6, false);
-
-  const bool7 = binding.basic_types_boolean.operatorBool(true);
-  assert.strictEqual(bool7, true);
-
-  const bool8 = binding.basic_types_boolean.operatorBool(false);
-  assert.strictEqual(bool8, false);
-}

package/vendor/node-addon-api/test/basic_types/number.cc

@@ -1,105 +0,0 @@
-#include <cfloat>
-
-#include "napi.h"
-
-using namespace Napi;
-
-Value ToInt32(const CallbackInfo& info) {
-  return Number::New(info.Env(), info[0].As<Number>().Int32Value());
-}
-
-Value ToUint32(const CallbackInfo& info) {
-  return Number::New(info.Env(), info[0].As<Number>().Uint32Value());
-}
-
-Value ToInt64(const CallbackInfo& info) {
-  return Number::New(info.Env(),
-                     static_cast<double>(info[0].As<Number>().Int64Value()));
-}
-
-Value ToFloat(const CallbackInfo& info) {
-  return Number::New(info.Env(), info[0].As<Number>().FloatValue());
-}
-
-Value ToDouble(const CallbackInfo& info) {
-  return Number::New(info.Env(), info[0].As<Number>().DoubleValue());
-}
-
-Value MinFloat(const CallbackInfo& info) {
-  return Number::New(info.Env(), FLT_MIN);
-}
-
-Value MaxFloat(const CallbackInfo& info) {
-  return Number::New(info.Env(), FLT_MAX);
-}
-
-Value MinDouble(const CallbackInfo& info) {
-  return Number::New(info.Env(), DBL_MIN);
-}
-
-Value MaxDouble(const CallbackInfo& info) {
-  return Number::New(info.Env(), DBL_MAX);
-}
-
-Value OperatorInt32(const CallbackInfo& info) {
-  Number number = info[0].As<Number>();
-  return Boolean::New(info.Env(),
-                      number.Int32Value() == static_cast<int32_t>(number));
-}
-
-Value OperatorUint32(const CallbackInfo& info) {
-  Number number = info[0].As<Number>();
-  return Boolean::New(info.Env(),
-                      number.Uint32Value() == static_cast<uint32_t>(number));
-}
-
-Value OperatorInt64(const CallbackInfo& info) {
-  Number number = info[0].As<Number>();
-  return Boolean::New(info.Env(),
-                      number.Int64Value() == static_cast<int64_t>(number));
-}
-
-Value OperatorFloat(const CallbackInfo& info) {
-  Number number = info[0].As<Number>();
-  return Boolean::New(info.Env(),
-                      number.FloatValue() == static_cast<float>(number));
-}
-
-Value OperatorDouble(const CallbackInfo& info) {
-  Number number = info[0].As<Number>();
-  return Boolean::New(info.Env(),
-                      number.DoubleValue() == static_cast<double>(number));
-}
-
-Value CreateEmptyNumber(const CallbackInfo& info) {
-  Number number;
-  return Boolean::New(info.Env(), number.IsEmpty());
-}
-
-Value CreateNumberFromExistingValue(const CallbackInfo& info) {
-  return info[0].As<Number>();
-}
-
-Object InitBasicTypesNumber(Env env) {
-  Object exports = Object::New(env);
-
-  exports["toInt32"] = Function::New(env, ToInt32);
-  exports["toUint32"] = Function::New(env, ToUint32);
-  exports["toInt64"] = Function::New(env, ToInt64);
-  exports["toFloat"] = Function::New(env, ToFloat);
-  exports["toDouble"] = Function::New(env, ToDouble);
-  exports["minFloat"] = Function::New(env, MinFloat);
-  exports["maxFloat"] = Function::New(env, MaxFloat);
-  exports["minDouble"] = Function::New(env, MinDouble);
-  exports["maxDouble"] = Function::New(env, MaxDouble);
-  exports["operatorInt32"] = Function::New(env, OperatorInt32);
-  exports["operatorUint32"] = Function::New(env, OperatorUint32);
-  exports["operatorInt64"] = Function::New(env, OperatorInt64);
-  exports["operatorFloat"] = Function::New(env, OperatorFloat);
-  exports["operatorDouble"] = Function::New(env, OperatorDouble);
-  exports["createEmptyNumber"] = Function::New(env, CreateEmptyNumber);
-  exports["createNumberFromExistingValue"] =
-      Function::New(env, CreateNumberFromExistingValue);
-
-  return exports;
-}

package/vendor/node-addon-api/test/basic_types/number.js

@@ -1,115 +0,0 @@
-/* eslint-disable no-lone-blocks */
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test (binding) {
-  const MIN_INT32 = -2147483648;
-  const MAX_INT32 = 2147483647;
-  const MIN_UINT32 = 0;
-  const MAX_UINT32 = 4294967295;
-  const MIN_INT64 = Number.MIN_SAFE_INTEGER;
-  const MAX_INT64 = Number.MAX_SAFE_INTEGER;
-  const MIN_FLOAT = binding.basic_types_number.minFloat();
-  const MAX_FLOAT = binding.basic_types_number.maxFloat();
-  const MIN_DOUBLE = binding.basic_types_number.minDouble();
-  const MAX_DOUBLE = binding.basic_types_number.maxDouble();
-
-  function randomRangeTestForInteger (min, max, converter) {
-    for (let i = min; i < max; i += Math.floor(Math.random() * max / 100)) {
-      assert.strictEqual(i, converter(i));
-    }
-  }
-
-  // Test for 32bit signed integer [-2147483648, 2147483647]
-  {
-    // Range tests
-    randomRangeTestForInteger(MIN_INT32, MAX_INT32, binding.basic_types_number.toInt32);
-    assert.strictEqual(MIN_INT32, binding.basic_types_number.toInt32(MIN_INT32));
-    assert.strictEqual(MAX_INT32, binding.basic_types_number.toInt32(MAX_INT32));
-
-    // Overflow tests
-    assert.notStrictEqual(MAX_INT32 + 1, binding.basic_types_number.toInt32(MAX_INT32 + 1));
-    assert.notStrictEqual(MIN_INT32 - 1, binding.basic_types_number.toInt32(MIN_INT32 - 1));
-  }
-
-  // Test for 32bit unsigned integer [0, 4294967295]
-  {
-    // Range tests
-    randomRangeTestForInteger(MIN_UINT32, MAX_UINT32, binding.basic_types_number.toUint32);
-    assert.strictEqual(MIN_UINT32, binding.basic_types_number.toUint32(MIN_UINT32));
-    assert.strictEqual(MAX_UINT32, binding.basic_types_number.toUint32(MAX_UINT32));
-
-    // Overflow tests
-    assert.notStrictEqual(MAX_UINT32 + 1, binding.basic_types_number.toUint32(MAX_UINT32 + 1));
-    assert.notStrictEqual(MIN_UINT32 - 1, binding.basic_types_number.toUint32(MIN_UINT32 - 1));
-  }
-
-  // Test for 64bit signed integer
-  {
-    // Range tests
-    randomRangeTestForInteger(MIN_INT64, MAX_INT64, binding.basic_types_number.toInt64);
-    assert.strictEqual(MIN_INT64, binding.basic_types_number.toInt64(MIN_INT64));
-    assert.strictEqual(MAX_INT64, binding.basic_types_number.toInt64(MAX_INT64));
-
-    // The int64 type can't be represented with full precision in JavaScript.
-    // So, we are not able to do overflow test here.
-    // Please see https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type.
-  }
-
-  // Test for float type (might be single-precision 32bit IEEE 754 floating point number)
-  {
-    // Range test
-    assert.strictEqual(MIN_FLOAT, binding.basic_types_number.toFloat(MIN_FLOAT));
-    assert.strictEqual(MAX_FLOAT, binding.basic_types_number.toFloat(MAX_FLOAT));
-
-    // Overflow test
-    assert.strictEqual(0, binding.basic_types_number.toFloat(MIN_FLOAT * MIN_FLOAT));
-    assert.strictEqual(Infinity, binding.basic_types_number.toFloat(MAX_FLOAT * MAX_FLOAT));
-  }
-
-  // Test for double type (is double-precision 64 bit IEEE 754 floating point number)
-  {
-    assert.strictEqual(MIN_DOUBLE, binding.basic_types_number.toDouble(MIN_DOUBLE));
-    assert.strictEqual(MAX_DOUBLE, binding.basic_types_number.toDouble(MAX_DOUBLE));
-
-    // Overflow test
-    assert.strictEqual(0, binding.basic_types_number.toDouble(MIN_DOUBLE * MIN_DOUBLE));
-    assert.strictEqual(Infinity, binding.basic_types_number.toDouble(MAX_DOUBLE * MAX_DOUBLE));
-  }
-
-  // Test for operator overloading
-  {
-    assert.strictEqual(binding.basic_types_number.operatorInt32(MIN_INT32), true);
-    assert.strictEqual(binding.basic_types_number.operatorInt32(MAX_INT32), true);
-    assert.strictEqual(binding.basic_types_number.operatorUint32(MIN_UINT32), true);
-    assert.strictEqual(binding.basic_types_number.operatorUint32(MAX_UINT32), true);
-    assert.strictEqual(binding.basic_types_number.operatorInt64(MIN_INT64), true);
-    assert.strictEqual(binding.basic_types_number.operatorInt64(MAX_INT64), true);
-    assert.strictEqual(binding.basic_types_number.operatorFloat(MIN_FLOAT), true);
-    assert.strictEqual(binding.basic_types_number.operatorFloat(MAX_FLOAT), true);
-    assert.strictEqual(binding.basic_types_number.operatorFloat(MAX_DOUBLE), true);
-    assert.strictEqual(binding.basic_types_number.operatorDouble(MIN_DOUBLE), true);
-    assert.strictEqual(binding.basic_types_number.operatorDouble(MAX_DOUBLE), true);
-  }
-
-  // Construction test
-  {
-    assert.strictEqual(binding.basic_types_number.createEmptyNumber(), true);
-    randomRangeTestForInteger(MIN_INT32, MAX_INT32, binding.basic_types_number.createNumberFromExistingValue);
-    assert.strictEqual(MIN_INT32, binding.basic_types_number.createNumberFromExistingValue(MIN_INT32));
-    assert.strictEqual(MAX_INT32, binding.basic_types_number.createNumberFromExistingValue(MAX_INT32));
-    randomRangeTestForInteger(MIN_UINT32, MAX_UINT32, binding.basic_types_number.createNumberFromExistingValue);
-    assert.strictEqual(MIN_UINT32, binding.basic_types_number.createNumberFromExistingValue(MIN_UINT32));
-    assert.strictEqual(MAX_UINT32, binding.basic_types_number.createNumberFromExistingValue(MAX_UINT32));
-    randomRangeTestForInteger(MIN_INT64, MAX_INT64, binding.basic_types_number.createNumberFromExistingValue);
-    assert.strictEqual(MIN_INT64, binding.basic_types_number.createNumberFromExistingValue(MIN_INT64));
-    assert.strictEqual(MAX_INT64, binding.basic_types_number.createNumberFromExistingValue(MAX_INT64));
-    assert.strictEqual(MIN_FLOAT, binding.basic_types_number.createNumberFromExistingValue(MIN_FLOAT));
-    assert.strictEqual(MAX_FLOAT, binding.basic_types_number.createNumberFromExistingValue(MAX_FLOAT));
-    assert.strictEqual(MIN_DOUBLE, binding.basic_types_number.createNumberFromExistingValue(MIN_DOUBLE));
-    assert.strictEqual(MAX_DOUBLE, binding.basic_types_number.createNumberFromExistingValue(MAX_DOUBLE));
-  }
-}

package/vendor/node-addon-api/test/basic_types/value.cc

@@ -1,177 +0,0 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-namespace {
-
-int testData = 1;
-
-// Helpers for testing non-Javascript values.
-Value CreateExternal(const CallbackInfo& info) {
-  return External<int>::New(info.Env(), &testData);
-}
-
-}  // end anonymous namespace
-
-static Value StrictlyEquals(const CallbackInfo& info) {
-  bool strictlyEquals = info[0].StrictEquals(info[1]);
-  return Boolean::New(info.Env(), strictlyEquals);
-}
-
-// tests the  '==' overload
-static Value StrictEqualsOverload(const CallbackInfo& info) {
-  bool strictlyEquals = info[0] == info[1];
-  return Boolean::New(info.Env(), strictlyEquals);
-}
-
-// tests the '!=' overload
-static Value StrictlyNotEqualsOverload(const CallbackInfo& info) {
-  bool strictlyEquals = info[0] != info[1];
-  return Boolean::New(info.Env(), strictlyEquals);
-}
-
-static Value ValueReturnsCorrectEnv(const CallbackInfo& info) {
-  Value testValue = CreateExternal(info);
-  return Boolean::New(info.Env(), testValue.Env() == info.Env());
-}
-
-static Value EmptyValueReturnNullPtrOnCast(const CallbackInfo& info) {
-  Value emptyValue;
-  bool isNullPtr = static_cast<napi_value>(emptyValue) == nullptr;
-  return Boolean::New(info.Env(), isNullPtr);
-}
-
-static Value NonEmptyValueReturnValOnCast(const CallbackInfo& info) {
-  Value boolValue = Value::From(info.Env(), true);
-  return Boolean::New(info.Env(), static_cast<napi_value>(boolValue));
-}
-
-static Value CreateNonEmptyValue(const CallbackInfo& info) {
-  return Napi::Value(info.Env(), String::New(info.Env(), "non_empty_val"));
-}
-
-static Value IsEmpty(const CallbackInfo& info) {
-  Value value;
-  return Boolean::New(info.Env(), value.IsEmpty());
-}
-
-static Value IsUndefined(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsUndefined());
-}
-
-static Value IsNull(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsNull());
-}
-
-static Value IsBoolean(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsBoolean());
-}
-
-static Value IsNumber(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsNumber());
-}
-
-static Value IsString(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsString());
-}
-
-static Value IsSymbol(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsSymbol());
-}
-
-static Value IsArray(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsArray());
-}
-
-static Value IsArrayBuffer(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsArrayBuffer());
-}
-
-static Value IsTypedArray(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsTypedArray());
-}
-
-static Value IsObject(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsObject());
-}
-
-static Value IsFunction(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsFunction());
-}
-
-static Value IsPromise(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsPromise());
-}
-
-static Value IsDataView(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsDataView());
-}
-
-static Value IsExternal(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsExternal());
-}
-
-static Value ToBoolean(const CallbackInfo& info) {
-  return MaybeUnwrap(info[0].ToBoolean());
-}
-
-static Value ToNumber(const CallbackInfo& info) {
-  return MaybeUnwrap(info[0].ToNumber());
-}
-
-static Value ToString(const CallbackInfo& info) {
-  return MaybeUnwrap(info[0].ToString());
-}
-
-static Value ToObject(const CallbackInfo& info) {
-  return MaybeUnwrap(info[0].ToObject());
-}
-
-static Value AccessProp(const CallbackInfo& info) {
-  Object obj = MaybeUnwrap(info[0].ToObject());
-  return obj[info[1]].AsValue();
-}
-
-Object InitBasicTypesValue(Env env) {
-  Object exports = Object::New(env);
-
-  exports["isEmpty"] = Function::New(env, IsEmpty);
-  exports["isUndefined"] = Function::New(env, IsUndefined);
-  exports["isNull"] = Function::New(env, IsNull);
-  exports["isBoolean"] = Function::New(env, IsBoolean);
-  exports["isNumber"] = Function::New(env, IsNumber);
-  exports["isString"] = Function::New(env, IsString);
-  exports["isSymbol"] = Function::New(env, IsSymbol);
-  exports["isArray"] = Function::New(env, IsArray);
-  exports["isArrayBuffer"] = Function::New(env, IsArrayBuffer);
-  exports["isTypedArray"] = Function::New(env, IsTypedArray);
-  exports["isObject"] = Function::New(env, IsObject);
-  exports["isFunction"] = Function::New(env, IsFunction);
-  exports["isPromise"] = Function::New(env, IsPromise);
-  exports["isDataView"] = Function::New(env, IsDataView);
-  exports["isExternal"] = Function::New(env, IsExternal);
-  exports["toBoolean"] = Function::New(env, ToBoolean);
-  exports["toNumber"] = Function::New(env, ToNumber);
-  exports["toString"] = Function::New(env, ToString);
-  exports["toObject"] = Function::New(env, ToObject);
-  exports["accessProp"] = Function::New(env, AccessProp);
-
-  exports["strictlyEquals"] = Function::New(env, StrictlyEquals);
-  exports["strictlyEqualsOverload"] = Function::New(env, StrictEqualsOverload);
-  exports["strictlyNotEqualsOverload"] =
-      Function::New(env, StrictlyNotEqualsOverload);
-
-  exports["assertValueReturnsCorrectEnv"] =
-      Function::New(env, ValueReturnsCorrectEnv);
-
-  exports["assertEmptyValReturnNullPtrOnCast"] =
-      Function::New(env, EmptyValueReturnNullPtrOnCast);
-  exports["assertNonEmptyReturnValOnCast"] =
-      Function::New(env, NonEmptyValueReturnValOnCast);
-
-  exports["createNonEmptyValue"] = Function::New(env, CreateNonEmptyValue);
-  exports["createExternal"] = Function::New(env, CreateExternal);
-
-  return exports;
-}