koffi 0.9.4 → 0.9.5

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

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