koffi 2.3.4 → 2.3.6-beta.1

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_threadsafe_function_unref.js

@@ -2,7 +2,7 @@
 
 const assert = require('assert');
 
-const isMainProcess = process.argv[1] != __filename;
+const isMainProcess = process.argv[1] !== __filename;
 
 /**
  * In order to test that the event loop exits even with an active TSFN, we need
@@ -11,43 +11,88 @@ const isMainProcess = process.argv[1] != __filename;
  *   - Child process: creates TSFN. Native module Unref's via setTimeout after some time but does NOT call Release.
  *
  * Main process should expect child process to exit.
+ *
+ * We also added a new test case for `Ref`. The idea being, if a TSFN is active, the event loop that it belongs to should not exit
+ * Our setup is similar to the test for the `Unref` case, with the difference being now we are expecting the child process to hang
  */
 
 if (isMainProcess) {
   module.exports = require('../common').runTestWithBindingPath(test);
 } else {
-  test(process.argv[2]);
+  const isTestingRef = (process.argv[3] === 'true');
+
+  if (isTestingRef) {
+    execTSFNRefTest(process.argv[2]);
+  } else {
+    execTSFNUnrefTest(process.argv[2]);
+  }
 }
 
-function test(bindingFile) {
-  if (isMainProcess) {
-    // Main process
+function testUnRefCallback (resolve, reject, bindingFile) {
+  const child = require('../napi_child').spawn(process.argv[0], [
+    '--expose-gc', __filename, bindingFile, false
+  ], { stdio: 'inherit' });
+
+  let timeout = setTimeout(function () {
+    child.kill();
+    timeout = 0;
+    reject(new Error('Expected child to die'));
+  }, 5000);
+
+  child.on('error', (err) => {
+    clearTimeout(timeout);
+    timeout = 0;
+    reject(new Error(err));
+  });
+
+  child.on('close', (code) => {
+    if (timeout) clearTimeout(timeout);
+    assert.strictEqual(code, 0, 'Expected return value 0');
+    resolve();
+  });
+}
+
+function testRefCallback (resolve, reject, bindingFile) {
+  const child = require('../napi_child').spawn(process.argv[0], [
+    '--expose-gc', __filename, bindingFile, true
+  ], { stdio: 'inherit' });
+
+  let timeout = setTimeout(function () {
+    child.kill();
+    timeout = 0;
+    resolve();
+  }, 1000);
+
+  child.on('error', (err) => {
+    clearTimeout(timeout);
+    timeout = 0;
+    reject(new Error(err));
+  });
+
+  child.on('close', (code) => {
+    if (timeout) clearTimeout(timeout);
+
+    reject(new Error('We expected Child to hang'));
+  });
+}
+
+function test (bindingFile) {
+  // Main process
+  return new Promise((resolve, reject) => {
+    testUnRefCallback(resolve, reject, bindingFile);
+  }).then(() => {
     return new Promise((resolve, reject) => {
-      const child = require('../napi_child').spawn(process.argv[0], [
-        '--expose-gc', __filename, bindingFile
-      ], { stdio: 'inherit' });
-
-      let timeout = setTimeout( function() {
-        child.kill();
-        timeout = 0;
-        reject(new Error("Expected child to die"));
-      }, 5000);
-
-      child.on("error", (err) => {
-        clearTimeout(timeout);
-        timeout = 0;
-        reject(new Error(err));
-      })
-
-      child.on("close", (code) => {
-        if (timeout) clearTimeout(timeout);
-        assert.strictEqual(code, 0, "Expected return value 0");
-        resolve();
-      });
+      testRefCallback(resolve, reject, bindingFile);
     });
-  } else {
-    // Child process
-    const binding = require(bindingFile);
-    binding.typed_threadsafe_function_unref.testUnref({}, () => { });
-  }
+  });
+}
+
+function execTSFNUnrefTest (bindingFile) {
+  const binding = require(bindingFile);
+  binding.typed_threadsafe_function_unref.testUnref({}, () => { });
+}
+
+function execTSFNRefTest (bindingFile) {
+  const binding = require(bindingFile);
+  binding.typed_threadsafe_function_unref.testRef({}, () => { });
 }

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

@@ -4,10 +4,10 @@ const assert = require('assert');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   [
     ['bigint64', BigInt64Array],
-    ['biguint64', BigUint64Array],
+    ['biguint64', BigUint64Array]
   ].forEach(([type, Constructor]) => {
     try {
       const length = 4;

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

@@ -1,14 +1,18 @@
+#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) \
+#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) \
+#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
 
@@ -18,91 +22,253 @@ Value CreateTypedArray(const CallbackInfo& info) {
   std::string arrayType = info[0].As<String>();
   size_t length = info[1].As<Number>().Uint32Value();
   ArrayBuffer buffer = info[2].As<ArrayBuffer>();
-  size_t bufferOffset = info[3].IsUndefined() ? 0 : info[3].As<Number>().Uint32Value();
+  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, bufferOffset,
-                                 napi_int8_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     Int8Array, info.Env(), length, napi_int8_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(Int8Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset,
-                                 napi_uint8_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     Uint8Array, info.Env(), length, napi_uint8_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(Uint8Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset, napi_uint8_clamped_array);
+    return buffer.IsUndefined()
+               ? Uint8Array::New(info.Env(), length, napi_uint8_clamped_array)
+               : Uint8Array::New(info.Env(),
+                                 length,
+                                 buffer,
+                                 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, bufferOffset,
-                                 napi_int16_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     Int16Array, info.Env(), length, napi_int16_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(Int16Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset,
-                                 napi_uint16_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     Uint16Array, info.Env(), length, napi_uint16_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(Uint16Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset,
-                                 napi_int32_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     Int32Array, info.Env(), length, napi_int32_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(Int32Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset,
-                                 napi_uint32_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     Uint32Array, info.Env(), length, napi_uint32_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(Uint32Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset,
-                                 napi_float32_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     Float32Array, info.Env(), length, napi_float32_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(Float32Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset,
-                                 napi_float64_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     Float64Array, info.Env(), length, napi_float64_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(Float64Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset,
-                                 napi_bigint64_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     BigInt64Array, info.Env(), length, napi_bigint64_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(BigInt64Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            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, bufferOffset,
-                                 napi_biguint64_array);
+    return buffer.IsUndefined()
+               ? NAPI_TYPEDARRAY_NEW(
+                     BigUint64Array, info.Env(), length, napi_biguint64_array)
+               : NAPI_TYPEDARRAY_NEW_BUFFER(BigUint64Array,
+                                            info.Env(),
+                                            length,
+                                            buffer,
+                                            bufferOffset,
+                                            napi_biguint64_array);
 #endif
   } else {
-    Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
+    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);
+  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");
+    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<int8_t>(info[0].As<Int8Array>(),
+                                             info[1].As<Int8Array>()));
+
+    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 String::New(info.Env(), "bigint64");
-    case napi_biguint64_array: return String::New(info.Env(), "biguint64");
+    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 String::New(info.Env(), "invalid");
+    default:
+      return Boolean::New(info.Env(), false);
   }
 }
 
@@ -111,6 +277,21 @@ Value GetTypedArrayLength(const CallbackInfo& info) {
   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();
@@ -145,7 +326,8 @@ Value GetTypedArrayElement(const CallbackInfo& info) {
       return BigInt::New(info.Env(), array.As<BigUint64Array>()[index]);
 #endif
     default:
-      Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
+      Error::New(info.Env(), "Invalid typed-array type.")
+          .ThrowAsJavaScriptException();
       return Value();
   }
 }
@@ -168,7 +350,8 @@ void SetTypedArrayElement(const CallbackInfo& info) {
       array.As<Int16Array>()[index] = static_cast<int16_t>(value.Int32Value());
       break;
     case napi_uint16_array:
-      array.As<Uint16Array>()[index] = static_cast<uint16_t>(value.Uint32Value());
+      array.As<Uint16Array>()[index] =
+          static_cast<uint16_t>(value.Uint32Value());
       break;
     case napi_int32_array:
       array.As<Int32Array>()[index] = value.Int32Value();
@@ -185,32 +368,42 @@ void SetTypedArrayElement(const CallbackInfo& info) {
 #if (NAPI_VERSION > 5)
     case napi_bigint64_array: {
       bool lossless;
-      array.As<BigInt64Array>()[index] = value.As<BigInt>().Int64Value(&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);
+      array.As<BigUint64Array>()[index] =
+          value.As<BigInt>().Uint64Value(&lossless);
       break;
     }
 #endif
     default:
-      Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
+      Error::New(info.Env(), "Invalid typed-array type.")
+          .ThrowAsJavaScriptException();
   }
 }
 
-} // end anonymous namespace
+}  // 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["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

@@ -4,19 +4,44 @@ const assert = require('assert');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   const testData = [
-    [ 'int8', Int8Array ],
-    [ 'uint8', Uint8Array ],
-    [ 'uint8_clamped', Uint8ClampedArray ],
-    [ 'int16', Int16Array ],
-    [ 'uint16', Uint16Array ],
-    [ 'int32', Int32Array ],
-    [ 'uint32', Uint32Array ],
-    [ 'float32', Float32Array ],
-    [ 'float64', Float64Array ],
+    ['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;
@@ -24,6 +49,9 @@ function test(binding) {
       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);
@@ -49,6 +77,9 @@ function test(binding) {
       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);
@@ -57,6 +88,9 @@ function test(binding) {
       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;