koffi 2.16.0-beta.2 → 2.16.0

package/vendor/node-addon-api/test/typedarray.cc

@@ -1,413 +0,0 @@
-#include <vector>
-#include "napi.h"
-using namespace Napi;
-
-#if defined(NAPI_HAS_CONSTEXPR)
-#define NAPI_TYPEDARRAY_NEW(className, env, length, type)                      \
-  className::New(env, length)
-#define NAPI_TYPEDARRAY_NEW_BUFFER(                                            \
-    className, env, length, buffer, bufferOffset, type)                        \
-  className::New(env, length, buffer, bufferOffset)
-#else
-#define NAPI_TYPEDARRAY_NEW(className, env, length, type)                      \
-  className::New(env, length, type)
-#define NAPI_TYPEDARRAY_NEW_BUFFER(                                            \
-    className, env, length, buffer, bufferOffset, type)                        \
-  className::New(env, length, buffer, bufferOffset, type)
-#endif
-
-namespace {
-
-Value CreateTypedArray(const CallbackInfo& info) {
-  std::string arrayType = info[0].As<String>();
-  size_t length = info[1].As<Number>().Uint32Value();
-  Value buffer = info[2];
-  size_t bufferOffset =
-      info[3].IsUndefined() ? 0 : info[3].As<Number>().Uint32Value();
-
-  if (arrayType == "int8") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     Int8Array, info.Env(), length, napi_int8_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(Int8Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_int8_array);
-  } else if (arrayType == "uint8") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     Uint8Array, info.Env(), length, napi_uint8_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(Uint8Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_uint8_array);
-  } else if (arrayType == "uint8_clamped") {
-    return buffer.IsUndefined()
-               ? Uint8Array::New(info.Env(), length, napi_uint8_clamped_array)
-               : Uint8Array::New(info.Env(),
-                                 length,
-                                 buffer.As<ArrayBuffer>(),
-                                 bufferOffset,
-                                 napi_uint8_clamped_array);
-  } else if (arrayType == "int16") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     Int16Array, info.Env(), length, napi_int16_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(Int16Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_int16_array);
-  } else if (arrayType == "uint16") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     Uint16Array, info.Env(), length, napi_uint16_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(Uint16Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_uint16_array);
-  } else if (arrayType == "int32") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     Int32Array, info.Env(), length, napi_int32_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(Int32Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_int32_array);
-  } else if (arrayType == "uint32") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     Uint32Array, info.Env(), length, napi_uint32_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(Uint32Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_uint32_array);
-  } else if (arrayType == "float32") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     Float32Array, info.Env(), length, napi_float32_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(Float32Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_float32_array);
-  } else if (arrayType == "float64") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     Float64Array, info.Env(), length, napi_float64_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(Float64Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_float64_array);
-#if (NAPI_VERSION > 5)
-  } else if (arrayType == "bigint64") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     BigInt64Array, info.Env(), length, napi_bigint64_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(BigInt64Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_bigint64_array);
-  } else if (arrayType == "biguint64") {
-    return buffer.IsUndefined()
-               ? NAPI_TYPEDARRAY_NEW(
-                     BigUint64Array, info.Env(), length, napi_biguint64_array)
-               : NAPI_TYPEDARRAY_NEW_BUFFER(BigUint64Array,
-                                            info.Env(),
-                                            length,
-                                            buffer.As<ArrayBuffer>(),
-                                            bufferOffset,
-                                            napi_biguint64_array);
-#endif
-  } else {
-    Error::New(info.Env(), "Invalid typed-array type.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CreateInvalidTypedArray(const CallbackInfo& info) {
-  return NAPI_TYPEDARRAY_NEW_BUFFER(
-      Int8Array, info.Env(), 1, ArrayBuffer(), 0, napi_int8_array);
-}
-
-Value GetTypedArrayType(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  switch (array.TypedArrayType()) {
-    case napi_int8_array:
-      return String::New(info.Env(), "int8");
-    case napi_uint8_array:
-      return String::New(info.Env(), "uint8");
-    case napi_uint8_clamped_array:
-      return String::New(info.Env(), "uint8_clamped");
-    case napi_int16_array:
-      return String::New(info.Env(), "int16");
-    case napi_uint16_array:
-      return String::New(info.Env(), "uint16");
-    case napi_int32_array:
-      return String::New(info.Env(), "int32");
-    case napi_uint32_array:
-      return String::New(info.Env(), "uint32");
-    case napi_float32_array:
-      return String::New(info.Env(), "float32");
-    case napi_float64_array:
-      return String::New(info.Env(), "float64");
-#if (NAPI_VERSION > 5)
-    case napi_bigint64_array:
-      return String::New(info.Env(), "bigint64");
-    case napi_biguint64_array:
-      return String::New(info.Env(), "biguint64");
-#endif
-    default:
-      return String::New(info.Env(), "invalid");
-  }
-}
-
-template <typename type>
-bool TypedArrayDataIsEquivalent(TypedArrayOf<type> arr,
-                                TypedArrayOf<type> inputArr) {
-  if (arr.ElementLength() != inputArr.ElementLength()) {
-    return false;
-  }
-  std::vector<type> bufferContent(arr.Data(), arr.Data() + arr.ElementLength());
-  std::vector<type> inputContent(inputArr.Data(),
-                                 inputArr.Data() + inputArr.ElementLength());
-  if (bufferContent != inputContent) {
-    return false;
-  }
-  return true;
-}
-
-Value CheckBufferContent(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-
-  switch (array.TypedArrayType()) {
-    case napi_int8_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<int8_t>(info[0].As<Int8Array>(),
-                                             info[1].As<Int8Array>()));
-
-      break;
-    case napi_uint8_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<uint8_t>(info[0].As<Uint8Array>(),
-                                              info[1].As<Uint8Array>()));
-
-    case napi_uint8_clamped_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<uint8_t>(info[0].As<Uint8Array>(),
-                                              info[1].As<Uint8Array>()));
-
-    case napi_int16_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<int16_t>(info[0].As<Int16Array>(),
-                                              info[1].As<Int16Array>()));
-
-    case napi_uint16_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<uint16_t>(info[0].As<Uint16Array>(),
-                                               info[1].As<Uint16Array>()));
-
-    case napi_int32_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<int32_t>(info[0].As<Int32Array>(),
-                                              info[1].As<Int32Array>()));
-
-    case napi_uint32_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<uint32_t>(info[0].As<Uint32Array>(),
-                                               info[1].As<Uint32Array>()));
-
-    case napi_float32_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<float>(info[0].As<Float32Array>(),
-                                            info[1].As<Float32Array>()));
-
-    case napi_float64_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<double>(info[0].As<Float64Array>(),
-                                             info[1].As<Float64Array>()));
-
-#if (NAPI_VERSION > 5)
-    case napi_bigint64_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<int64_t>(info[0].As<BigInt64Array>(),
-                                              info[1].As<BigInt64Array>()));
-
-    case napi_biguint64_array:
-      return Boolean::New(
-          info.Env(),
-          TypedArrayDataIsEquivalent<uint64_t>(info[0].As<BigUint64Array>(),
-                                               info[1].As<BigUint64Array>()));
-
-#endif
-    default:
-      return Boolean::New(info.Env(), false);
-  }
-}
-
-Value GetTypedArrayLength(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  return Number::New(info.Env(), static_cast<double>(array.ElementLength()));
-}
-
-Value GetTypedArraySize(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  return Number::New(info.Env(), static_cast<double>(array.ElementSize()));
-}
-
-Value GetTypedArrayByteOffset(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  return Number::New(info.Env(), static_cast<double>(array.ByteOffset()));
-}
-
-Value GetTypedArrayByteLength(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  return Number::New(info.Env(), static_cast<double>(array.ByteLength()));
-}
-
-Value GetTypedArrayBuffer(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  return array.ArrayBuffer();
-}
-
-Value GetTypedArrayElement(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  size_t index = info[1].As<Number>().Uint32Value();
-  switch (array.TypedArrayType()) {
-    case napi_int8_array:
-      return Number::New(info.Env(), array.As<Int8Array>()[index]);
-    case napi_uint8_array:
-      return Number::New(info.Env(), array.As<Uint8Array>()[index]);
-    case napi_uint8_clamped_array:
-      return Number::New(info.Env(), array.As<Uint8Array>()[index]);
-    case napi_int16_array:
-      return Number::New(info.Env(), array.As<Int16Array>()[index]);
-    case napi_uint16_array:
-      return Number::New(info.Env(), array.As<Uint16Array>()[index]);
-    case napi_int32_array:
-      return Number::New(info.Env(), array.As<Int32Array>()[index]);
-    case napi_uint32_array:
-      return Number::New(info.Env(), array.As<Uint32Array>()[index]);
-    case napi_float32_array:
-      return Number::New(info.Env(), array.As<Float32Array>()[index]);
-    case napi_float64_array:
-      return Number::New(info.Env(), array.As<Float64Array>()[index]);
-#if (NAPI_VERSION > 5)
-    case napi_bigint64_array:
-      return BigInt::New(info.Env(), array.As<BigInt64Array>()[index]);
-    case napi_biguint64_array:
-      return BigInt::New(info.Env(), array.As<BigUint64Array>()[index]);
-#endif
-    default:
-      Error::New(info.Env(), "Invalid typed-array type.")
-          .ThrowAsJavaScriptException();
-      return Value();
-  }
-}
-
-void SetTypedArrayElement(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  size_t index = info[1].As<Number>().Uint32Value();
-  Value value = info[2];
-  switch (array.TypedArrayType()) {
-    case napi_int8_array:
-      array.As<Int8Array>()[index] =
-          static_cast<int8_t>(value.As<Number>().Int32Value());
-      break;
-    case napi_uint8_array:
-      array.As<Uint8Array>()[index] =
-          static_cast<uint8_t>(value.As<Number>().Uint32Value());
-      break;
-    case napi_uint8_clamped_array:
-      array.As<Uint8Array>()[index] =
-          static_cast<uint8_t>(value.As<Number>().Uint32Value());
-      break;
-    case napi_int16_array:
-      array.As<Int16Array>()[index] =
-          static_cast<int16_t>(value.As<Number>().Int32Value());
-      break;
-    case napi_uint16_array:
-      array.As<Uint16Array>()[index] =
-          static_cast<uint16_t>(value.As<Number>().Uint32Value());
-      break;
-    case napi_int32_array:
-      array.As<Int32Array>()[index] = value.As<Number>().Int32Value();
-      break;
-    case napi_uint32_array:
-      array.As<Uint32Array>()[index] = value.As<Number>().Uint32Value();
-      break;
-    case napi_float32_array:
-      array.As<Float32Array>()[index] = value.As<Number>().FloatValue();
-      break;
-    case napi_float64_array:
-      array.As<Float64Array>()[index] = value.As<Number>().DoubleValue();
-      break;
-#if (NAPI_VERSION > 5)
-    case napi_bigint64_array: {
-      bool lossless;
-      array.As<BigInt64Array>()[index] =
-          value.As<BigInt>().Int64Value(&lossless);
-      break;
-    }
-    case napi_biguint64_array: {
-      bool lossless;
-      array.As<BigUint64Array>()[index] =
-          value.As<BigInt>().Uint64Value(&lossless);
-      break;
-    }
-#endif
-    default:
-      Error::New(info.Env(), "Invalid typed-array type.")
-          .ThrowAsJavaScriptException();
-  }
-}
-
-}  // end anonymous namespace
-
-Object InitTypedArray(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createTypedArray"] = Function::New(env, CreateTypedArray);
-  exports["createInvalidTypedArray"] =
-      Function::New(env, CreateInvalidTypedArray);
-  exports["getTypedArrayType"] = Function::New(env, GetTypedArrayType);
-  exports["getTypedArrayLength"] = Function::New(env, GetTypedArrayLength);
-  exports["getTypedArraySize"] = Function::New(env, GetTypedArraySize);
-  exports["getTypedArrayByteOffset"] =
-      Function::New(env, GetTypedArrayByteOffset);
-  exports["getTypedArrayByteLength"] =
-      Function::New(env, GetTypedArrayByteLength);
-  exports["getTypedArrayBuffer"] = Function::New(env, GetTypedArrayBuffer);
-  exports["getTypedArrayElement"] = Function::New(env, GetTypedArrayElement);
-  exports["setTypedArrayElement"] = Function::New(env, SetTypedArrayElement);
-  exports["checkBufferContent"] = Function::New(env, CheckBufferContent);
-
-  return exports;
-}

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

@@ -1,103 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  const testData = [
-    ['int8', Int8Array, 1, new Int8Array([0, 124, 24, 44])],
-    ['uint8', Uint8Array, 1, new Uint8Array([0, 255, 2, 14])],
-    ['uint8_clamped', Uint8ClampedArray, 1, new Uint8ClampedArray([0, 256, 0, 255])],
-    ['int16', Int16Array, 2, new Int16Array([-32768, 32767, 1234, 42])],
-    ['uint16', Uint16Array, 2, new Uint16Array([0, 65535, 4, 12])],
-    ['int32', Int32Array, 4, new Int32Array([Math.pow(2, 31), Math.pow(-2, 31), 255, 4])],
-    ['uint32', Uint32Array, 4, new Uint32Array([0, Math.pow(2, 32), 24, 125])],
-    ['float32', Float32Array, 4, new Float32Array([0, 21, 34, 45])],
-    ['float64', Float64Array, 8, new Float64Array([0, 4124, 45, 90])]
-  ];
-
-  const bigIntTests = [
-    ['bigint64', BigInt64Array, 8, new BigInt64Array([9007199254740991n, 9007199254740991n, 24n, 125n])],
-    ['biguint64', BigUint64Array, 8, new BigUint64Array([9007199254740991n, 9007199254740991n, 2345n, 345n])]
-  ];
-
-  bigIntTests.forEach(data => {
-    const length = 4;
-    const t = binding.typedarray.createTypedArray(data[0], length);
-    assert.ok(t instanceof data[1]);
-    assert.strictEqual(binding.typedarray.getTypedArrayType(t), data[0]);
-    assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
-    assert.strictEqual(binding.typedarray.getTypedArraySize(t), data[2]);
-    assert.strictEqual(binding.typedarray.getTypedArrayByteOffset(t), 0);
-    assert.strictEqual(binding.typedarray.getTypedArrayByteLength(t), data[2] * length);
-
-    t[3] = 11n;
-    assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
-    binding.typedarray.setTypedArrayElement(t, 3, 22n);
-    assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
-    assert.strictEqual(t[3], 22n);
-
-    const nonEmptyTypedArray = binding.typedarray.createTypedArray(data[0], length, data[3].buffer);
-    binding.typedarray.checkBufferContent(nonEmptyTypedArray, data[3]);
-  });
-
-  testData.forEach(data => {
-    try {
-      const length = 4;
-      const t = binding.typedarray.createTypedArray(data[0], length);
-      assert.ok(t instanceof data[1]);
-      assert.strictEqual(binding.typedarray.getTypedArrayType(t), data[0]);
-      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
-      assert.strictEqual(binding.typedarray.getTypedArraySize(t), data[2]);
-      assert.strictEqual(binding.typedarray.getTypedArrayByteOffset(t), 0);
-      assert.strictEqual(binding.typedarray.getTypedArrayByteLength(t), data[2] * length);
-
-      t[3] = 11;
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11);
-      binding.typedarray.setTypedArrayElement(t, 3, 22);
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22);
-      assert.strictEqual(t[3], 22);
-
-      const b = binding.typedarray.getTypedArrayBuffer(t);
-      assert.ok(b instanceof ArrayBuffer);
-    } catch (e) {
-      console.log(data);
-      throw e;
-    }
-  });
-
-  testData.forEach(data => {
-    try {
-      const length = 4;
-      const offset = 8;
-      const b = new ArrayBuffer(offset + 64 * 4);
-
-      const t = binding.typedarray.createTypedArray(data[0], length, b, offset);
-      assert.ok(t instanceof data[1]);
-      assert.strictEqual(binding.typedarray.getTypedArrayType(t), data[0]);
-      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
-      assert.strictEqual(binding.typedarray.getTypedArraySize(t), data[2]);
-      assert.strictEqual(binding.typedarray.getTypedArrayByteOffset(t), offset);
-      assert.strictEqual(binding.typedarray.getTypedArrayByteLength(t), data[2] * length);
-
-      t[3] = 11;
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11);
-      binding.typedarray.setTypedArrayElement(t, 3, 22);
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22);
-      assert.strictEqual(t[3], 22);
-
-      assert.strictEqual(binding.typedarray.getTypedArrayBuffer(t), b);
-
-      const nonEmptyTypedArray = binding.typedarray.createTypedArray(data[0], length, data[3].buffer);
-      assert.strictEqual(binding.typedarray.checkBufferContent(nonEmptyTypedArray, data[3]), true);
-    } catch (e) {
-      console.log(data);
-      throw e;
-    }
-  });
-
-  assert.throws(() => {
-    binding.typedarray.createInvalidTypedArray();
-  }, /Invalid (pointer passed as )?argument/);
-}

package/vendor/node-addon-api/test/value_type_cast.cc

@@ -1,60 +0,0 @@
-#include "common/test_helper.h"
-#include "napi.h"
-
-using namespace Napi;
-
-#define TYPE_CAST_TYPES(V)                                                     \
-  V(Boolean)                                                                   \
-  V(Number)                                                                    \
-  V(BigInt)                                                                    \
-  V(Date)                                                                      \
-  V(String)                                                                    \
-  V(Symbol)                                                                    \
-  V(Object)                                                                    \
-  V(Array)                                                                     \
-  V(ArrayBuffer)                                                               \
-  V(TypedArray)                                                                \
-  V(DataView)                                                                  \
-  V(Function)                                                                  \
-  V(Promise)
-
-// The following types are tested individually.
-// External
-// TypedArrayOf
-// Buffer
-
-namespace {
-#define V(Type)                                                                \
-  void TypeCast##Type(const CallbackInfo& info) { USE(info[0].As<Type>()); }
-TYPE_CAST_TYPES(V)
-#undef V
-
-void TypeCastBuffer(const CallbackInfo& info) {
-  USE(info[0].As<Buffer<uint8_t>>());
-}
-
-void TypeCastExternal(const CallbackInfo& info) {
-  USE(info[0].As<External<void>>());
-}
-
-void TypeCastTypeArrayOfUint8(const CallbackInfo& info) {
-  USE(info[0].As<TypedArrayOf<uint8_t>>());
-}
-}  // namespace
-
-Object InitValueTypeCast(Env env, Object exports) {
-  exports["external"] = External<void>::New(env, nullptr);
-
-#define V(Type) exports["typeCast" #Type] = Function::New(env, TypeCast##Type);
-  TYPE_CAST_TYPES(V)
-#undef V
-
-  exports["typeCastBuffer"] = Function::New(env, TypeCastBuffer);
-  exports["typeCastExternal"] = Function::New(env, TypeCastExternal);
-  exports["typeCastTypeArrayOfUint8"] =
-      Function::New(env, TypeCastTypeArrayOfUint8);
-
-  return exports;
-}
-
-NODE_API_MODULE(addon, InitValueTypeCast)

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

@@ -1,106 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const napiChild = require('./napi_child');
-
-module.exports = require('./common').runTestWithBuildType(test);
-
-function test (buildType) {
-  const binding = require(`./build/${buildType}/binding_type_check.node`);
-  const testTable = {
-    typeCastBoolean: {
-      positiveValues: [true, false],
-      negativeValues: [{}, [], 1, 1n, 'true', null, undefined]
-    },
-    typeCastNumber: {
-      positiveValues: [1, NaN],
-      negativeValues: [{}, [], true, 1n, '1', null, undefined]
-    },
-    typeCastBigInt: {
-      positiveValues: [1n],
-      negativeValues: [{}, [], true, 1, '1', null, undefined]
-    },
-    typeCastDate: {
-      positiveValues: [new Date()],
-      negativeValues: [{}, [], true, 1, 1n, '1', null, undefined]
-    },
-    typeCastString: {
-      positiveValues: ['', '1'],
-      negativeValues: [{}, [], true, 1, 1n, null, undefined]
-    },
-    typeCastSymbol: {
-      positiveValues: [Symbol('1')],
-      negativeValues: [{}, [], true, 1, 1n, '1', null, undefined]
-    },
-    typeCastObject: {
-      positiveValues: [{}, new Date(), []],
-      negativeValues: [true, 1, 1n, '1', null, undefined]
-    },
-    typeCastArray: {
-      positiveValues: [[1]],
-      negativeValues: [{}, true, 1, 1n, '1', null, undefined]
-    },
-    typeCastArrayBuffer: {
-      positiveValues: [new ArrayBuffer(0)],
-      negativeValues: [new Uint8Array(1), {}, [], null, undefined]
-    },
-    typeCastTypedArray: {
-      positiveValues: [new Uint8Array(0)],
-      negativeValues: [new ArrayBuffer(1), {}, [], null, undefined]
-    },
-    typeCastDataView: {
-      positiveValues: [new DataView(new ArrayBuffer(0))],
-      negativeValues: [new ArrayBuffer(1), null, undefined]
-    },
-    typeCastFunction: {
-      positiveValues: [() => {}],
-      negativeValues: [{}, null, undefined]
-    },
-    typeCastPromise: {
-      positiveValues: [Promise.resolve()],
-      // napi_is_promise distinguishes Promise and thenable.
-      negativeValues: [{ then: () => {} }, null, undefined]
-    },
-    typeCastBuffer: {
-      positiveValues: [Buffer.from('')],
-      // napi_is_buffer doesn't distinguish between Buffer and TypedArrays.
-      negativeValues: [new ArrayBuffer(1), null, undefined]
-    },
-    typeCastExternal: {
-      positiveValues: [binding.external],
-      negativeValues: [{}, null, undefined]
-    },
-    typeCastTypeArrayOfUint8: {
-      // TypedArrayOf<uint8_t>::CheckCast doesn't distinguish between Uint8ClampedArray and Uint8Array.
-      positiveValues: [new Uint8Array(0), new Uint8ClampedArray(0)],
-      negativeValues: [new Int8Array(1), null, undefined]
-    }
-  };
-
-  if (process.argv[2] === 'child') {
-    child(binding, testTable, process.argv[3], process.argv[4], parseInt(process.argv[5]));
-    return;
-  }
-
-  for (const [methodName, { positiveValues, negativeValues }] of Object.entries(testTable)) {
-    for (const idx of positiveValues.keys()) {
-      const { status } = napiChild.spawnSync(process.execPath, [__filename, 'child', methodName, 'positiveValues', idx]);
-      assert.strictEqual(status, 0, `${methodName} positive value ${idx} test failed`);
-    }
-    for (const idx of negativeValues.keys()) {
-      const { status, signal, stderr } = napiChild.spawnSync(process.execPath, [__filename, 'child', methodName, 'negativeValues', idx], {
-        encoding: 'utf8'
-      });
-      if (process.platform === 'win32') {
-        assert.strictEqual(status, 128 + 6 /* SIGABRT */, `${methodName} negative value ${idx} test failed`);
-      } else {
-        assert.strictEqual(signal, 'SIGABRT', `${methodName} negative value ${idx} test failed`);
-      }
-      assert.ok(stderr.match(/FATAL ERROR: .*::CheckCast.*/));
-    }
-  }
-}
-
-async function child (binding, testTable, methodName, type, idx) {
-  binding[methodName](testTable[methodName][type][idx]);
-}