koffi 1.0.3 → 1.1.0-beta.0

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

@@ -1,24 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-function test(binding, succeed) {
-  return new Promise((resolve) =>
-    // Can't pass an arrow function to doWork because that results in an
-    // undefined context inside its body when the function gets called.
-    binding.doWork(succeed, function(e) {
-      setImmediate(() => {
-        // If the work is supposed to fail, make sure there's an error.
-        assert.strictEqual(succeed || e.message === 'test error', true);
-        assert.strictEqual(binding.workerGone, false);
-        binding.deleteWorker();
-        assert.strictEqual(binding.workerGone, true);
-        resolve();
-      });
-    }));
-}
-
-module.exports = require('./common').runTest(async binding => {
-  await test(binding.persistentasyncworker, false);
-  await test(binding.persistentasyncworker, true);
-});

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,35 +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,38 +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,35 +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,99 +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,114 +0,0 @@
-'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,120 +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 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());
-}
-
-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["createExternal"] = Function::New(env, CreateExternal);
-
-  return exports;
-}

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

@@ -1,133 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  const externalValue = binding.basic_types_value.createExternal();
-
-  function isObject(value) {
-    return (typeof value === 'object' && value !== externalValue) ||
-           (typeof value === 'function');
-  }
-
-  function detailedTypeOf(value) {
-    const type = typeof value;
-    if (type !== 'object')
-      return type;
-
-    if (value === null)
-      return 'null';
-
-    if (Array.isArray(value))
-      return 'array';
-
-    if (value === externalValue)
-      return 'external';
-
-    if (!value.constructor)
-      return type;
-
-    if (value instanceof ArrayBuffer)
-      return 'arraybuffer';
-
-    if (ArrayBuffer.isView(value)) {
-      if (value instanceof DataView) {
-        return 'dataview';
-      } else {
-        return 'typedarray';
-      }
-    }
-
-    if (value instanceof Promise)
-      return 'promise';
-
-    return 'object';
-  }
-
-  function typeCheckerTest(typeChecker, expectedType) {
-    const testValueList = [
-      undefined,
-      null,
-      true,
-      10,
-      'string',
-      Symbol('symbol'),
-      [],
-      new ArrayBuffer(10),
-      new Int32Array(new ArrayBuffer(12)),
-      {},
-      function() {},
-      new Promise((resolve, reject) => {}),
-      new DataView(new ArrayBuffer(12)),
-      externalValue
-    ];
-
-    testValueList.forEach((testValue) => {
-      if (testValue !== null && expectedType === 'object') {
-        assert.strictEqual(typeChecker(testValue), isObject(testValue));
-      } else {
-        assert.strictEqual(typeChecker(testValue), detailedTypeOf(testValue) === expectedType);
-      }
-    });
-  }
-
-  function typeConverterTest(typeConverter, expectedType) {
-    const testValueList = [
-      true,
-      false,
-      0,
-      10,
-      'string',
-      [],
-      new ArrayBuffer(10),
-      new Int32Array(new ArrayBuffer(12)),
-      {},
-      function() {},
-      new Promise((resolve, reject) => {})
-    ];
-
-    testValueList.forEach((testValue) => {
-      const expected = expectedType(testValue);
-      const actual = typeConverter(testValue);
-
-      if (isNaN(expected)) {
-        assert(isNaN(actual));
-      } else {
-        assert.deepStrictEqual(typeConverter(testValue), expectedType(testValue));
-      }
-    });
-  }
-
-  const value = binding.basic_types_value;
-
-  typeCheckerTest(value.isUndefined, 'undefined');
-  typeCheckerTest(value.isNull, 'null');
-  typeCheckerTest(value.isBoolean, 'boolean');
-  typeCheckerTest(value.isNumber, 'number');
-  typeCheckerTest(value.isString, 'string');
-  typeCheckerTest(value.isSymbol, 'symbol');
-  typeCheckerTest(value.isArray, 'array');
-  typeCheckerTest(value.isArrayBuffer, 'arraybuffer');
-  typeCheckerTest(value.isTypedArray, 'typedarray');
-  typeCheckerTest(value.isObject, 'object');
-  typeCheckerTest(value.isFunction, 'function');
-  typeCheckerTest(value.isPromise, 'promise');
-  typeCheckerTest(value.isDataView, 'dataview');
-  typeCheckerTest(value.isExternal, 'external');
-
-  typeConverterTest(value.toBoolean, Boolean);
-  assert.strictEqual(value.toBoolean(undefined), false);
-  assert.strictEqual(value.toBoolean(null), false);
-
-  typeConverterTest(value.toNumber, Number);
-  assert(isNaN(value.toNumber(undefined)));
-  assert.strictEqual(value.toNumber(null), 0);
-
-  typeConverterTest(value.toString, String);
-  assert.strictEqual(value.toString(undefined), 'undefined');
-  assert.strictEqual(value.toString(null), 'null');
-
-  typeConverterTest(value.toObject, Object);
-}