Moved buf test to ES6

Author: lutovich

test/internal/buf.test.js

@@ -17,134 +17,134 @@
  * limitations under the License.
  */
 
-var alloc = require('../../lib/v1/internal/buf').alloc;
-var CombinedBuffer = require('../../lib/v1/internal/buf').CombinedBuffer;
-var utf8 = require('../../lib/v1/internal/utf8').default;
-var Unpacker = require("../../lib/v1/internal/packstream.js").Unpacker;
+import {Unpacker} from '../../src/v1/internal/packstream-v1';
+import utf8 from '../../src/v1/internal/utf8';
+import {alloc, CombinedBuffer} from '../../src/v1/internal/buf';
 
-describe('buffers', function() {
-  it('should have helpful toString', function() {
+describe('buffers', () => {
+
+  it('should have helpful toString', () => {
     // Given
-    var b = alloc(4);
+    const b = alloc(4);
     b.writeInt8(1);
     b.writeInt8(8);
     b.writeInt8(15);
     b.writeInt8(127);
 
     // When
-    var str = b.toString();
-    var hex = b.toHex();
+    const str = b.toString();
+    const hex = b.toHex();
 
     // Then
-    expect( str ).toContain("( position=4 )\n  01 08 0f 7f");
-    expect(hex).toBe("01 08 0f 7f ");
+    expect(str).toContain('( position=4 )\n  01 08 0f 7f');
+    expect(hex).toBe('01 08 0f 7f ');
   });
 
-  it('should read and write 8-bit unsigned integers', function() {
+  it('should read and write 8-bit unsigned integers', () => {
     // Given
-    var b = alloc(1);
+    const b = alloc(1);
 
-    for (var i = 0; i < 7; i++) {
-      var n = Math.pow(2, i);
+    for (let i = 0; i < 7; i++) {
+      const n = Math.pow(2, i);
 
       // When
-      b.putUInt8( 0, n );
+      b.putUInt8(0, n);
 
       // Then
-      expect( b.getUInt8(0) ).toBe( n );
+      expect(b.getUInt8(0)).toBe(n);
     }
   });
 
-  it('should read and write 16-bit unsigned integers', function() {
+  it('should read and write 16-bit unsigned integers', () => {
     // Given
-    var b = alloc(2);
+    const b = alloc(2);
 
-    for (var i = 0; i < 15; i++) {
-      var n = Math.pow(2, i);
+    for (let i = 0; i < 15; i++) {
+      const n = Math.pow(2, i);
 
       // When
-      b.putUInt16( 0, n );
+      b.putUInt16(0, n);
 
       // Then
-      expect( b.getUInt16(0) ).toBe( n );
+      expect(b.getUInt16(0)).toBe(n);
     }
   });
 
-  it('should read and write 32-bit unsigned integers', function() {
+  it('should read and write 32-bit unsigned integers', () => {
     // Given
-    var b = alloc(4);
+    const b = alloc(4);
 
-    for (var i = 0; i < 30; i++) {
-      var n = Math.pow(2, i);
+    for (let i = 0; i < 30; i++) {
+      const n = Math.pow(2, i);
 
       // When
-      b.putUInt32( 0, n );
+      b.putUInt32(0, n);
 
       // Then
-      expect( b.getUInt32(0) ).toBe( n );
+      expect(b.getUInt32(0)).toBe(n);
     }
   });
 
-  it('should read and write 8-bit signed integers', function() {
+  it('should read and write 8-bit signed integers', () => {
     // Given
-    var b = alloc(1);
+    const b = alloc(1);
 
-    for (var i = 0; i < 6; i++) {
-      var n = Math.pow(2, i);
+    for (let i = 0; i < 6; i++) {
+      const n = Math.pow(2, i);
 
       // When
-      b.putInt8( 0, n );
+      b.putInt8(0, n);
 
       // Then
-      expect( b.getInt8(0) ).toBe( n );
+      expect(b.getInt8(0)).toBe(n);
     }
   });
 
-  it('should read and write 16-bit signed integers', function() {
+  it('should read and write 16-bit signed integers', () => {
     // Given
-    var b = alloc(2);
+    const b = alloc(2);
 
-    for (var i = 0; i < 14; i++) {
-      var n = Math.pow(2, i);
+    for (let i = 0; i < 14; i++) {
+      const n = Math.pow(2, i);
 
       // When
-      b.putInt16( 0, n );
+      b.putInt16(0, n);
 
       // Then
-      expect( b.getInt16(0) ).toBe( n );
+      expect(b.getInt16(0)).toBe(n);
     }
   });
 
-  it('should read and write 32-bit signed integers', function() {
+  it('should read and write 32-bit signed integers', () => {
     // Given
-    var b = alloc(4);
+    const b = alloc(4);
 
-    for (var i = 0; i < 30; i++) {
-      var n = Math.pow(2, i);
+    for (let i = 0; i < 30; i++) {
+      const n = Math.pow(2, i);
 
       // When
-      b.putInt32( 0, n );
+      b.putInt32(0, n);
 
       // Then
-      expect( b.getInt32(0) ).toBe( n );
+      expect(b.getInt32(0)).toBe(n);
     }
   });
 
-  it('should encode list correctly', function() {
+  it('should encode list correctly', () => {
     // Given
-    var b = alloc(5);
+    let b = alloc(5);
     b.writeUInt8(0x90 | 0x2);
     b = writeString(b, 'a');
     b = writeString(b, 'b');
     // When
-    var hex = b.toHex();
+    const hex = b.toHex();
     // Then
-    expect(hex).toBe("92 81 61 81 62 ");
+    expect(hex).toBe('92 81 61 81 62 ');
   });
 
-  it('should decode list correctly', function() {
+  it('should decode list correctly', () => {
     // Given
-    var b = alloc(5);
+    const b = alloc(5);
     b.writeUInt8(0x92);
     b.writeUInt8(0x81);
     b.writeUInt8(0x61);
@@ -153,51 +153,52 @@ describe('buffers', function() {
     b.reset();
 
     // When
-    var data = new Unpacker().unpack( b );
+    const data = new Unpacker().unpack(b);
 
     // Then
     expect(data[0]).toBe('a');
     expect(data[1]).toBe('b');
   });
 });
 
-describe('CombinedBuffer', function() {
-  it('should read int8', function() {
+describe('CombinedBuffer', () => {
+
+  it('should read int8', () => {
     // Given
-    var b1 = alloc(1);
-    var b2 = alloc(1);
+    const b1 = alloc(1);
+    const b2 = alloc(1);
     b1.putInt8(0, 1);
     b2.putInt8(0, 2);
 
-    var b = new CombinedBuffer([b1,b2]);
-    
+    const b = new CombinedBuffer([b1, b2]);
+
     // When
-    var first = b.readInt8();
-    var second = b.readInt8();
+    const first = b.readInt8();
+    const second = b.readInt8();
 
     // Then
     expect(first).toBe(1);
     expect(second).toBe(2);
   });
 
-  it('should read divided float64', function() {
+  it('should read divided float64', () => {
     // Given
-    var inner = alloc(8);
+    const inner = alloc(8);
     inner.putFloat64(0, 0.1);
 
-    var b = new CombinedBuffer([inner.readSlice(4),inner.readSlice(4)]);
-    
+    const b = new CombinedBuffer([inner.readSlice(4), inner.readSlice(4)]);
+
     // When
-    var read = b.readFloat64();
+    const read = b.readFloat64();
 
     // Then
     expect(read).toBe(0.1);
   });
 });
 
 function writeString(b, str) {
-  var bytes = utf8.encode(str);
-  var size = bytes.length;
+  const bytes = utf8.encode(str);
+  const size = bytes.length;
   b.writeUInt8(0x80 | size);
   b.writeBytes(bytes);
   return b;