koffi 0.9.1 → 0.9.4

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

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

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

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

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

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

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

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

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

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