koffi 2.3.3 → 2.3.5

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

@@ -1,7 +1,81 @@
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include "assert.h"
 #include "napi.h"
 
 using namespace Napi;
 
+class TestWorkerWithUserDefRecv : public AsyncWorker {
+ public:
+  static void DoWork(const CallbackInfo& info) {
+    Object recv = info[0].As<Object>();
+    Function cb = info[1].As<Function>();
+
+    TestWorkerWithUserDefRecv* worker = new TestWorkerWithUserDefRecv(recv, cb);
+    worker->Queue();
+  }
+
+  static void DoWorkWithAsyncRes(const CallbackInfo& info) {
+    Object recv = info[0].As<Object>();
+    Function cb = info[1].As<Function>();
+    Object resource = info[2].As<Object>();
+
+    TestWorkerWithUserDefRecv* worker = nullptr;
+    if (resource == info.Env().Null()) {
+      worker = new TestWorkerWithUserDefRecv(recv, cb, "TestResource");
+    } else {
+      worker =
+          new TestWorkerWithUserDefRecv(recv, cb, "TestResource", resource);
+    }
+
+    worker->Queue();
+  }
+
+ protected:
+  void Execute() override {}
+
+ private:
+  TestWorkerWithUserDefRecv(const Object& recv, const Function& cb)
+      : AsyncWorker(recv, cb) {}
+  TestWorkerWithUserDefRecv(const Object& recv,
+                            const Function& cb,
+                            const char* resource_name)
+      : AsyncWorker(recv, cb, resource_name) {}
+  TestWorkerWithUserDefRecv(const Object& recv,
+                            const Function& cb,
+                            const char* resource_name,
+                            const Object& resource)
+      : AsyncWorker(recv, cb, resource_name, resource) {}
+};
+
+// Using default std::allocator impl, but assuming user can define their own
+// alloc/dealloc methods
+class CustomAllocWorker : public AsyncWorker {
+ public:
+  CustomAllocWorker(Function& cb) : AsyncWorker(cb){};
+  static void DoWork(const CallbackInfo& info) {
+    Function cb = info[0].As<Function>();
+    std::allocator<CustomAllocWorker> create_alloc;
+    CustomAllocWorker* newWorker = create_alloc.allocate(1);
+    create_alloc.construct(newWorker, cb);
+    newWorker->Queue();
+  }
+
+ protected:
+  void Execute() override {}
+  void Destroy() override {
+    assert(this->_secretVal == 24);
+    std::allocator<CustomAllocWorker> deallocer;
+    deallocer.destroy(this);
+    deallocer.deallocate(this, 1);
+  }
+
+ private:
+  int _secretVal = 24;
+};
+
 class TestWorker : public AsyncWorker {
  public:
   static void DoWork(const CallbackInfo& info) {
@@ -10,7 +84,13 @@ class TestWorker : public AsyncWorker {
     Function cb = info[2].As<Function>();
     Value data = info[3];
 
-    TestWorker* worker = new TestWorker(cb, "TestResource", resource);
+    TestWorker* worker = nullptr;
+    if (resource == info.Env().Null()) {
+      worker = new TestWorker(cb, "TestResource");
+    } else {
+      worker = new TestWorker(cb, "TestResource", resource);
+    }
+
     worker->Receiver().Set("data", data);
     worker->_succeed = succeed;
     worker->Queue();
@@ -26,6 +106,8 @@ class TestWorker : public AsyncWorker {
  private:
   TestWorker(Function cb, const char* resource_name, const Object& resource)
       : AsyncWorker(cb, resource_name, resource) {}
+  TestWorker(Function cb, const char* resource_name)
+      : AsyncWorker(cb, resource_name) {}
   bool _succeed;
 };
 
@@ -67,12 +149,25 @@ class TestWorkerWithResult : public AsyncWorker {
 class TestWorkerNoCallback : public AsyncWorker {
  public:
   static Value DoWork(const CallbackInfo& info) {
+    bool succeed = info[0].As<Boolean>();
+
+    TestWorkerNoCallback* worker = new TestWorkerNoCallback(info.Env());
+    worker->_succeed = succeed;
+    worker->Queue();
+    return worker->_deferred.Promise();
+  }
+
+  static Value DoWorkWithAsyncRes(const CallbackInfo& info) {
     napi_env env = info.Env();
     bool succeed = info[0].As<Boolean>();
     Object resource = info[1].As<Object>();
 
-    TestWorkerNoCallback* worker =
-        new TestWorkerNoCallback(env, "TestResource", resource);
+    TestWorkerNoCallback* worker = nullptr;
+    if (resource == info.Env().Null()) {
+      worker = new TestWorkerNoCallback(env, "TestResource");
+    } else {
+      worker = new TestWorkerNoCallback(env, "TestResource", resource);
+    }
     worker->_succeed = succeed;
     worker->Queue();
     return worker->_deferred.Promise();
@@ -86,6 +181,13 @@ class TestWorkerNoCallback : public AsyncWorker {
   }
 
  private:
+  TestWorkerNoCallback(Napi::Env env)
+      : AsyncWorker(env), _deferred(Napi::Promise::Deferred::New(env)) {}
+
+  TestWorkerNoCallback(napi_env env, const char* resource_name)
+      : AsyncWorker(env, resource_name),
+        _deferred(Napi::Promise::Deferred::New(env)) {}
+
   TestWorkerNoCallback(napi_env env,
                        const char* resource_name,
                        const Object& resource)
@@ -95,12 +197,143 @@ class TestWorkerNoCallback : public AsyncWorker {
   bool _succeed;
 };
 
+class EchoWorker : public AsyncWorker {
+ public:
+  EchoWorker(Function& cb, std::string& echo) : AsyncWorker(cb), echo(echo) {}
+  ~EchoWorker() {}
+
+  void Execute() override {
+    // Simulate cpu heavy task
+    std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  }
+
+  void OnOK() override {
+    HandleScope scope(Env());
+    Callback().Call({Env().Null(), String::New(Env(), echo)});
+  }
+
+ private:
+  std::string echo;
+};
+
+class FailCancelWorker : public AsyncWorker {
+ private:
+  bool taskIsRunning = false;
+  std::mutex mu;
+  std::condition_variable taskStartingCv;
+  void NotifyJSThreadTaskHasStarted() {
+    {
+      std::lock_guard<std::mutex> lk(mu);
+      taskIsRunning = true;
+      taskStartingCv.notify_one();
+    }
+  }
+
+ public:
+  FailCancelWorker(Function& cb) : AsyncWorker(cb) {}
+  ~FailCancelWorker() {}
+
+  void WaitForWorkerTaskToStart() {
+    std::unique_lock<std::mutex> lk(mu);
+    taskStartingCv.wait(lk, [this] { return taskIsRunning; });
+    taskIsRunning = false;
+  }
+
+  static void DoCancel(const CallbackInfo& info) {
+    Function cb = info[0].As<Function>();
+
+    FailCancelWorker* cancelWorker = new FailCancelWorker(cb);
+    cancelWorker->Queue();
+    cancelWorker->WaitForWorkerTaskToStart();
+
+#ifdef NAPI_CPP_EXCEPTIONS
+    try {
+      cancelWorker->Cancel();
+    } catch (Napi::Error&) {
+      Napi::Error::New(info.Env(), "Unable to cancel async worker tasks")
+          .ThrowAsJavaScriptException();
+    }
+#else
+    cancelWorker->Cancel();
+#endif
+  }
+
+  void Execute() override {
+    NotifyJSThreadTaskHasStarted();
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+  }
+
+  void OnOK() override {}
+
+  void OnError(const Error&) override {}
+};
+
+class CancelWorker : public AsyncWorker {
+ public:
+  CancelWorker(Function& cb) : AsyncWorker(cb) {}
+  ~CancelWorker() {}
+
+  static void DoWork(const CallbackInfo& info) {
+    Function cb = info[0].As<Function>();
+    std::string echo = info[1].As<String>();
+    int threadNum = info[2].As<Number>().Uint32Value();
+
+    for (int i = 0; i < threadNum; i++) {
+      AsyncWorker* worker = new EchoWorker(cb, echo);
+      worker->Queue();
+      assert(worker->Env() == info.Env());
+    }
+
+    AsyncWorker* cancelWorker = new CancelWorker(cb);
+    cancelWorker->Queue();
+
+#ifdef NAPI_CPP_EXCEPTIONS
+    try {
+      cancelWorker->Cancel();
+    } catch (Napi::Error&) {
+      Napi::Error::New(info.Env(), "Unable to cancel async worker tasks")
+          .ThrowAsJavaScriptException();
+    }
+#else
+    cancelWorker->Cancel();
+#endif
+  }
+
+  void Execute() override {
+    // Simulate cpu heavy task
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  void OnOK() override {
+    Napi::Error::New(this->Env(),
+                     "OnOk should not be invoked on successful cancellation")
+        .ThrowAsJavaScriptException();
+  }
+
+  void OnError(const Error&) override {
+    Napi::Error::New(this->Env(),
+                     "OnError should not be invoked on successful cancellation")
+        .ThrowAsJavaScriptException();
+  }
+};
+
 Object InitAsyncWorker(Env env) {
   Object exports = Object::New(env);
+  exports["doWorkRecv"] = Function::New(env, TestWorkerWithUserDefRecv::DoWork);
+  exports["doWithRecvAsyncRes"] =
+      Function::New(env, TestWorkerWithUserDefRecv::DoWorkWithAsyncRes);
   exports["doWork"] = Function::New(env, TestWorker::DoWork);
+  exports["doWorkAsyncResNoCallback"] =
+      Function::New(env, TestWorkerNoCallback::DoWorkWithAsyncRes);
   exports["doWorkNoCallback"] =
       Function::New(env, TestWorkerNoCallback::DoWork);
   exports["doWorkWithResult"] =
       Function::New(env, TestWorkerWithResult::DoWork);
+  exports["tryCancelQueuedWork"] = Function::New(env, CancelWorker::DoWork);
+
+  exports["expectCancelToFail"] =
+      Function::New(env, FailCancelWorker::DoCancel);
+  exports["expectCustomAllocWorkerToDealloc"] =
+      Function::New(env, CustomAllocWorker::DoWork);
   return exports;
 }

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

@@ -4,12 +4,12 @@ const common = require('./common');
 
 // we only check async hooks on 8.x an higher were
 // they are closer to working properly
-const nodeVersion = process.versions.node.split('.')[0]
-let async_hooks = undefined;
-function checkAsyncHooks() {
-  if (nodeVersion >=8) {
-    if (async_hooks == undefined) {
-      async_hooks = require('async_hooks');
+const nodeVersion = process.versions.node.split('.')[0];
+let asyncHooks;
+function checkAsyncHooks () {
+  if (nodeVersion >= 8) {
+    if (asyncHooks === undefined) {
+      asyncHooks = require('async_hooks');
     }
     return true;
   }
@@ -18,7 +18,7 @@ function checkAsyncHooks() {
 
 module.exports = common.runTest(test);
 
-function installAsyncHooksForTest() {
+function installAsyncHooksForTest () {
   return new Promise((resolve, reject) => {
     let id;
     const events = [];
@@ -26,34 +26,33 @@ function installAsyncHooksForTest() {
      * TODO(legendecas): investigate why resolving & disabling hooks in
      * destroy callback causing crash with case 'callbackscope.js'.
      */
-     let hook;
-     let destroyed = false;
-     const interval = setInterval(() => {
-       if (destroyed) {
-         hook.disable();
-         clearInterval(interval);
-         resolve(events);
-       }
-     }, 10);
-
-    hook = async_hooks.createHook({
-      init(asyncId, type, triggerAsyncId, resource) {
+    let destroyed = false;
+    const interval = setInterval(() => {
+      if (destroyed) {
+        hook.disable();
+        clearInterval(interval);
+        resolve(events);
+      }
+    }, 10);
+
+    const hook = asyncHooks.createHook({
+      init (asyncId, type, triggerAsyncId, resource) {
         if (id === undefined && type === 'TestResource') {
           id = asyncId;
           events.push({ eventName: 'init', type, triggerAsyncId, resource });
         }
       },
-      before(asyncId) {
+      before (asyncId) {
         if (asyncId === id) {
           events.push({ eventName: 'before' });
         }
       },
-      after(asyncId) {
+      after (asyncId) {
         if (asyncId === id) {
           events.push({ eventName: 'after' });
         }
       },
-      destroy(asyncId) {
+      destroy (asyncId) {
         if (asyncId === id) {
           events.push({ eventName: 'destroy' });
           destroyed = true;
@@ -63,10 +62,34 @@ function installAsyncHooksForTest() {
   });
 }
 
-async function test(binding) {
+async function test (binding) {
+  const libUvThreadCount = Number(process.env.UV_THREADPOOL_SIZE || 4);
+  binding.asyncworker.tryCancelQueuedWork(() => {}, 'echoString', libUvThreadCount);
+
+  let taskFailed = false;
+  try {
+    binding.asyncworker.expectCancelToFail(() => {});
+  } catch (e) {
+    taskFailed = true;
+  }
+
+  assert.equal(taskFailed, true, 'We expect task cancellation to fail');
+
   if (!checkAsyncHooks()) {
+    binding.asyncworker.expectCustomAllocWorkerToDealloc(() => {});
+
+    await new Promise((resolve) => {
+      const obj = { data: 'test data' };
+      binding.asyncworker.doWorkRecv(obj, function (e) {
+        assert.strictEqual(typeof e, 'undefined');
+        assert.strictEqual(typeof this, 'object');
+        assert.strictEqual(this.data, 'test data');
+        resolve();
+      });
+    });
+
     await new Promise((resolve) => {
-      binding.asyncworker.doWork(true, {}, function (e) {
+      binding.asyncworker.doWork(true, null, function (e) {
         assert.strictEqual(typeof e, 'undefined');
         assert.strictEqual(typeof this, 'object');
         assert.strictEqual(this.data, 'test data');
@@ -86,9 +109,9 @@ async function test(binding) {
 
     await new Promise((resolve) => {
       binding.asyncworker.doWorkWithResult(true, {}, function (succeed, succeedString) {
-        assert(arguments.length == 2);
+        assert(arguments.length === 2);
         assert(succeed);
-        assert(succeedString == "ok");
+        assert(succeedString === 'ok');
         assert.strictEqual(typeof this, 'object');
         assert.strictEqual(this.data, 'test data');
         resolve();
@@ -100,7 +123,63 @@ async function test(binding) {
 
   {
     const hooks = installAsyncHooksForTest();
-    const triggerAsyncId = async_hooks.executionAsyncId();
+    const triggerAsyncId = asyncHooks.executionAsyncId();
+    await new Promise((resolve) => {
+      const recvObj = { data: 'test data' };
+      binding.asyncworker.doWithRecvAsyncRes(recvObj, function (e) {
+        assert.strictEqual(typeof e, 'undefined');
+        assert.strictEqual(typeof this, 'object');
+        assert.strictEqual(this.data, 'test data');
+        resolve();
+      }, { foo: 'fooBar' });
+    });
+
+    await hooks.then(actual => {
+      assert.deepStrictEqual(actual, [
+        {
+          eventName: 'init',
+          type: 'TestResource',
+          triggerAsyncId: triggerAsyncId,
+          resource: { foo: 'fooBar' }
+        },
+        { eventName: 'before' },
+        { eventName: 'after' },
+        { eventName: 'destroy' }
+      ]);
+    }).catch(common.mustNotCall());
+  }
+
+  {
+    const hooks = installAsyncHooksForTest();
+    const triggerAsyncId = asyncHooks.executionAsyncId();
+    await new Promise((resolve) => {
+      const recvObj = { data: 'test data' };
+      binding.asyncworker.doWithRecvAsyncRes(recvObj, function (e) {
+        assert.strictEqual(typeof e, 'undefined');
+        assert.strictEqual(typeof this, 'object');
+        assert.strictEqual(this.data, 'test data');
+        resolve();
+      }, null);
+    });
+
+    await hooks.then(actual => {
+      assert.deepStrictEqual(actual, [
+        {
+          eventName: 'init',
+          type: 'TestResource',
+          triggerAsyncId: triggerAsyncId,
+          resource: { }
+        },
+        { eventName: 'before' },
+        { eventName: 'after' },
+        { eventName: 'destroy' }
+      ]);
+    }).catch(common.mustNotCall());
+  }
+
+  {
+    const hooks = installAsyncHooksForTest();
+    const triggerAsyncId = asyncHooks.executionAsyncId();
     await new Promise((resolve) => {
       binding.asyncworker.doWork(true, { foo: 'foo' }, function (e) {
         assert.strictEqual(typeof e, 'undefined');
@@ -112,10 +191,12 @@ async function test(binding) {
 
     await hooks.then(actual => {
       assert.deepStrictEqual(actual, [
-        { eventName: 'init',
+        {
+          eventName: 'init',
           type: 'TestResource',
           triggerAsyncId: triggerAsyncId,
-          resource: { foo: 'foo' } },
+          resource: { foo: 'foo' }
+        },
         { eventName: 'before' },
         { eventName: 'after' },
         { eventName: 'destroy' }
@@ -125,13 +206,13 @@ async function test(binding) {
 
   {
     const hooks = installAsyncHooksForTest();
-    const triggerAsyncId = async_hooks.executionAsyncId();
+    const triggerAsyncId = asyncHooks.executionAsyncId();
     await new Promise((resolve) => {
       binding.asyncworker.doWorkWithResult(true, { foo: 'foo' },
         function (succeed, succeedString) {
-          assert(arguments.length == 2);
+          assert(arguments.length === 2);
           assert(succeed);
-          assert(succeedString == "ok");
+          assert(succeedString === 'ok');
           assert.strictEqual(typeof this, 'object');
           assert.strictEqual(this.data, 'test data');
           resolve();
@@ -140,10 +221,12 @@ async function test(binding) {
 
     await hooks.then(actual => {
       assert.deepStrictEqual(actual, [
-        { eventName: 'init',
+        {
+          eventName: 'init',
           type: 'TestResource',
           triggerAsyncId: triggerAsyncId,
-          resource: { foo: 'foo' } },
+          resource: { foo: 'foo' }
+        },
         { eventName: 'before' },
         { eventName: 'after' },
         { eventName: 'destroy' }
@@ -153,7 +236,7 @@ async function test(binding) {
 
   {
     const hooks = installAsyncHooksForTest();
-    const triggerAsyncId = async_hooks.executionAsyncId();
+    const triggerAsyncId = asyncHooks.executionAsyncId();
     await new Promise((resolve) => {
       binding.asyncworker.doWork(false, { foo: 'foo' }, function (e) {
         assert.ok(e instanceof Error);
@@ -166,10 +249,12 @@ async function test(binding) {
 
     await hooks.then(actual => {
       assert.deepStrictEqual(actual, [
-        { eventName: 'init',
+        {
+          eventName: 'init',
           type: 'TestResource',
           triggerAsyncId: triggerAsyncId,
-          resource: { foo: 'foo' } },
+          resource: { foo: 'foo' }
+        },
         { eventName: 'before' },
         { eventName: 'after' },
         { eventName: 'destroy' }

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

@@ -4,10 +4,16 @@ const common = require('./common');
 
 module.exports = common.runTest(test);
 
-async function test(binding) {
-  await binding.asyncworker.doWorkNoCallback(true, {})
+async function test (binding) {
+  await binding.asyncworker.doWorkAsyncResNoCallback(true, {})
     .then(common.mustCall()).catch(common.mustNotCall());
 
-  await binding.asyncworker.doWorkNoCallback(false, {})
+  await binding.asyncworker.doWorkAsyncResNoCallback(false, {})
+    .then(common.mustNotCall()).catch(common.mustCall());
+
+  await binding.asyncworker.doWorkNoCallback(false)
+    .then(common.mustNotCall()).catch(common.mustCall());
+
+  await binding.asyncworker.doWorkNoCallback(true)
     .then(common.mustNotCall()).catch(common.mustCall());
 }

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

@@ -2,11 +2,11 @@
 
 const assert = require('assert');
 
-function test(binding, succeed) {
+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) {
+    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);

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

@@ -3,8 +3,7 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-
+function test (binding) {
   // create empty array
   const array = binding.basic_types_array.createArray();
   assert.strictEqual(binding.basic_types_array.getLength(array), 0);
@@ -15,7 +14,7 @@ function test(binding) {
 
   // 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, 1, 'test');
   binding.basic_types_array.set(array, 2, 3.0);
 
   // check length after set data
@@ -23,7 +22,7 @@ function test(binding) {
 
   // 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, 1), 'test');
   assert.strictEqual(binding.basic_types_array.get(array, 2), 3.0);
 
   // overwrite test

package/vendor/node-addon-api/test/basic_types/boolean.cc

@@ -31,8 +31,10 @@ Object InitBasicTypesBoolean(Env 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["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

@@ -4,7 +4,7 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   const bool1 = binding.basic_types_boolean.createBoolean(true);
   assert.strictEqual(bool1, true);
 
@@ -31,5 +31,4 @@ function test(binding) {
 
   const bool8 = binding.basic_types_boolean.operatorBool(false);
   assert.strictEqual(bool8, false);
-
 }

package/vendor/node-addon-api/test/basic_types/number.cc

@@ -43,27 +43,32 @@ Value MaxDouble(const CallbackInfo& info) {
 
 Value OperatorInt32(const CallbackInfo& info) {
   Number number = info[0].As<Number>();
-  return Boolean::New(info.Env(), number.Int32Value() == static_cast<int32_t>(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));
+  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));
+  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));
+  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));
+  return Boolean::New(info.Env(),
+                      number.DoubleValue() == static_cast<double>(number));
 }
 
 Value CreateEmptyNumber(const CallbackInfo& info) {
@@ -93,7 +98,8 @@ Object InitBasicTypesNumber(Env env) {
   exports["operatorFloat"] = Function::New(env, OperatorFloat);
   exports["operatorDouble"] = Function::New(env, OperatorDouble);
   exports["createEmptyNumber"] = Function::New(env, CreateEmptyNumber);
-  exports["createNumberFromExistingValue"] = Function::New(env, CreateNumberFromExistingValue);
+  exports["createNumberFromExistingValue"] =
+      Function::New(env, CreateNumberFromExistingValue);
 
   return exports;
 }