diff --git a/lib/nodejs/test/binary.test.js b/lib/nodejs/test/binary.test.js
index 187cd18..343d39a 100644
--- a/lib/nodejs/test/binary.test.js
+++ b/lib/nodejs/test/binary.test.js
@@ -21,7 +21,7 @@
 const binary = require("thrift/binary");
 
 const cases = {
-  "Should read signed byte": function(assert) {
+  "Should read signed byte": function (assert) {
     assert.equal(1, binary.readByte(0x01));
     assert.equal(-1, binary.readByte(0xff));
 
@@ -29,12 +29,12 @@
     assert.equal(-128, binary.readByte(0x80));
     assert.end();
   },
-  "Should write byte": function(assert) {
+  "Should write byte": function (assert) {
     //Protocol simply writes to the buffer. Nothing to test.. yet.
     assert.ok(true);
     assert.end();
   },
-  "Should read I16": function(assert) {
+  "Should read I16": function (assert) {
     assert.equal(0, binary.readI16([0x00, 0x00]));
     assert.equal(1, binary.readI16([0x00, 0x01]));
     assert.equal(-1, binary.readI16([0xff, 0xff]));
@@ -46,7 +46,7 @@
     assert.end();
   },
 
-  "Should write I16": function(assert) {
+  "Should write I16": function (assert) {
     assert.deepEqual([0x00, 0x00], binary.writeI16([], 0));
     assert.deepEqual([0x00, 0x01], binary.writeI16([], 1));
     assert.deepEqual([0xff, 0xff], binary.writeI16([], -1));
@@ -58,7 +58,7 @@
     assert.end();
   },
 
-  "Should read I32": function(assert) {
+  "Should read I32": function (assert) {
     assert.equal(0, binary.readI32([0x00, 0x00, 0x00, 0x00]));
     assert.equal(1, binary.readI32([0x00, 0x00, 0x00, 0x01]));
     assert.equal(-1, binary.readI32([0xff, 0xff, 0xff, 0xff]));
@@ -70,7 +70,7 @@
     assert.end();
   },
 
-  "Should write I32": function(assert) {
+  "Should write I32": function (assert) {
     assert.deepEqual([0x00, 0x00, 0x00, 0x00], binary.writeI32([], 0));
     assert.deepEqual([0x00, 0x00, 0x00, 0x01], binary.writeI32([], 1));
     assert.deepEqual([0xff, 0xff, 0xff, 0xff], binary.writeI32([], -1));
@@ -78,137 +78,139 @@
     // Min I32
     assert.deepEqual(
       [0x80, 0x00, 0x00, 0x00],
-      binary.writeI32([], -2147483648)
+      binary.writeI32([], -2147483648),
     );
     // Max I32
     assert.deepEqual([0x7f, 0xff, 0xff, 0xff], binary.writeI32([], 2147483647));
     assert.end();
   },
 
-  "Should read doubles": function(assert) {
+  "Should read doubles": function (assert) {
     assert.equal(
       0,
-      binary.readDouble([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+      binary.readDouble([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
     );
     assert.equal(
       0,
-      binary.readDouble([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+      binary.readDouble([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
     );
     assert.equal(
       1,
-      binary.readDouble([0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+      binary.readDouble([0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
     );
     assert.equal(
       2,
-      binary.readDouble([0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+      binary.readDouble([0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
     );
     assert.equal(
       -2,
-      binary.readDouble([0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+      binary.readDouble([0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
     );
 
     assert.equal(
       Math.PI,
-      binary.readDouble([0x40, 0x9, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18])
+      binary.readDouble([0x40, 0x9, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18]),
     );
 
     assert.equal(
       Infinity,
-      binary.readDouble([0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+      binary.readDouble([0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
     );
     assert.equal(
       -Infinity,
-      binary.readDouble([0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+      binary.readDouble([0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
     );
 
     assert.ok(
-      isNaN(binary.readDouble([0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
+      isNaN(
+        binary.readDouble([0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+      ),
     );
 
     assert.equal(
       1 / 3,
-      binary.readDouble([0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55])
+      binary.readDouble([0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
     );
 
     // Min subnormal positive double
     assert.equal(
       4.9406564584124654e-324,
-      binary.readDouble([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01])
+      binary.readDouble([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]),
     );
     // Min normal positive double
     assert.equal(
       2.2250738585072014e-308,
-      binary.readDouble([0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+      binary.readDouble([0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
     );
     // Max positive double
     assert.equal(
       1.7976931348623157e308,
-      binary.readDouble([0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
+      binary.readDouble([0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
     );
     assert.end();
   },
 
-  "Should write doubles": function(assert) {
+  "Should write doubles": function (assert) {
     assert.deepEqual(
       [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-      binary.writeDouble([], 0)
+      binary.writeDouble([], 0),
     );
     assert.deepEqual(
       [0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-      binary.writeDouble([], 1)
+      binary.writeDouble([], 1),
     );
     assert.deepEqual(
       [0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-      binary.writeDouble([], 2)
+      binary.writeDouble([], 2),
     );
     assert.deepEqual(
       [0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-      binary.writeDouble([], -2)
+      binary.writeDouble([], -2),
     );
 
     assert.deepEqual(
       [0x40, 0x9, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18],
-      binary.writeDouble([], Math.PI)
+      binary.writeDouble([], Math.PI),
     );
 
     assert.deepEqual(
       [0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-      binary.writeDouble([], Infinity)
+      binary.writeDouble([], Infinity),
     );
     assert.deepEqual(
       [0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-      binary.writeDouble([], -Infinity)
+      binary.writeDouble([], -Infinity),
     );
 
     assert.deepEqual(
       [0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-      binary.writeDouble([], NaN)
+      binary.writeDouble([], NaN),
     );
 
     assert.deepEqual(
       [0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55],
-      binary.writeDouble([], 1 / 3)
+      binary.writeDouble([], 1 / 3),
     );
 
     // Min subnormal positive double
     assert.deepEqual(
       [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01],
-      binary.writeDouble([], 4.9406564584124654e-324)
+      binary.writeDouble([], 4.9406564584124654e-324),
     );
     // Min normal positive double
     assert.deepEqual(
       [0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
-      binary.writeDouble([], 2.2250738585072014e-308)
+      binary.writeDouble([], 2.2250738585072014e-308),
     );
     // Max positive double
     assert.deepEqual(
       [0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
-      binary.writeDouble([], 1.7976931348623157e308)
+      binary.writeDouble([], 1.7976931348623157e308),
     );
     assert.end();
-  }
+  },
 };
 
-Object.keys(cases).forEach(function(caseName) {
+Object.keys(cases).forEach(function (caseName) {
   test(caseName, cases[caseName]);
 });