test: merge test cases.

Author: ghosind

test/array.spec.ts

@@ -3,82 +3,65 @@ import { describe, it } from 'mocha';
 
 import { DynamicBuffer } from '../src';
 
-describe('CopyWithin tests', () => {
-  it('Test copyWithin', () => {
+describe('CopyWithin method tests', () => {
+  it('Test copyWithin method', () => {
     const buf = new DynamicBuffer('abcde');
-
     assert.equal(buf.copyWithin(0, 3, 4).toString(), 'dbcde');
     assert.equal(buf.copyWithin(1, 3).toString(), 'ddede');
-  });
 
-  it('Test copyWithin of empty buffer', () => {
-    const buf = new DynamicBuffer();
-
-    assert.equal(buf.copyWithin(0, 3, 4).toString(), '');
+    const empty = new DynamicBuffer();
+    assert.equal(empty.copyWithin(0, 3, 4).toString(), '');
   });
 });
 
-describe('Every tests', () => {
-  it('Test every', () => {
+describe('Every method tests', () => {
+  it('Test every method', () => {
     const buf1 = new DynamicBuffer('hello');
     const buf2 = new DynamicBuffer('Hello');
-
     assert.equal(buf1.every((v) => v >= 97 && v <= 122), true);
     assert.equal(buf2.every((v) => v >= 97 && v <= 122), false);
-  });
-
-  it('Test empty buffer\'s every method', () => {
-    const buf = new DynamicBuffer();
 
-    assert.equal(buf.every((v) => v >= 97 && v <= 122), true);
+    const empty = new DynamicBuffer();
+    assert.equal(empty.every((v) => v >= 97 && v <= 122), true);
   });
 });
 
-describe('Filter tests', () => {
-  it('Test filter', () => {
+describe('Filter method tests', () => {
+  it('Test filter method', () => {
     const buf = new DynamicBuffer('Hello');
+    assert.deepEqual(
+      buf.filter((v) => v >= 97 && v <= 122),
+      new Uint8Array([101, 108, 108, 111]),
+    );
 
-    assert.deepEqual(buf.filter((v) => v >= 97 && v <= 122), new Uint8Array([101, 108, 108, 111]));
-  });
-
-  it('Test empty buffer\'s filter method', () => {
-    const buf = new DynamicBuffer();
-
-    assert.deepEqual(buf.filter((v) => v >= 97 && v <= 122), new Uint8Array());
+    const empty = new DynamicBuffer();
+    assert.deepEqual(empty.filter((v) => v >= 97 && v <= 122), new Uint8Array());
   });
 });
 
-describe('Find tests', () => {
-  it('Test find', () => {
+describe('Find method tests', () => {
+  it('Test find method', () => {
     const buf = new DynamicBuffer('Hello');
-
     assert.equal(buf.find((v) => v >= 97 && v <= 122), 101);
     assert.equal(buf.find((v) => v >= 48 && v <= 57), undefined);
-  });
 
-  it('Test empty buffer\'s find method', () => {
-    const buf = new DynamicBuffer();
-
-    assert.equal(buf.find((v) => v >= 97 && v <= 122), undefined);
+    const empty = new DynamicBuffer();
+    assert.equal(empty.find((v) => v >= 97 && v <= 122), undefined);
   });
 });
 
-describe('FindIndex tests', () => {
-  it('Test findIndex', () => {
+describe('FindIndex method tests', () => {
+  it('Test findIndex method', () => {
     const buf = new DynamicBuffer('Hello');
-
     assert.equal(buf.findIndex((v) => v >= 97 && v <= 122), 1);
     assert.equal(buf.findIndex((v) => v >= 48 && v <= 57), -1);
-  });
-
-  it('Test empty buffer\'s findIndex method', () => {
-    const buf = new DynamicBuffer();
 
-    assert.equal(buf.findIndex((v) => v >= 97 && v <= 122), -1);
+    const empty = new DynamicBuffer();
+    assert.equal(empty.findIndex((v) => v >= 97 && v <= 122), -1);
   });
 });
 
-describe('ForEach tests', () => {
+describe('ForEach method tests', () => {
   it('Test forEach', () => {
     const buf = new DynamicBuffer('Hello');
     const arr: number[] = [];
@@ -108,49 +91,35 @@ describe('ForEach tests', () => {
   });
 });
 
-describe('Join tests', () => {
-  it('Test join', () => {
+describe('Join method tests', () => {
+  it('Test join method', () => {
     const buf = new DynamicBuffer('Hello');
-
     assert.equal(buf.join(), '72,101,108,108,111');
     assert.equal(buf.join('|'), '72|101|108|108|111');
-  });
-
-  it('Test empty buffer\'s join method', () => {
-    const buf = new DynamicBuffer();
 
-    assert.equal(buf.join(), '');
+    const empty = new DynamicBuffer();
+    assert.equal(empty.join(), '');
   });
 });
 
-describe('Map tests', () => {
-  it('Test map', () => {
+describe('Map method tests', () => {
+  it('Test map method', () => {
     const buf = new DynamicBuffer('Hello');
-
     assert.deepEqual(buf.map((v) => v + 1), new Uint8Array([73, 102, 109, 109, 112]));
-  });
 
-  it('Test empty buffer\'s map method', () => {
-    const buf = new DynamicBuffer();
-
-    assert.deepEqual(buf.map((v) => v + 1), new Uint8Array());
+    const empty = new DynamicBuffer();
+    assert.deepEqual(empty.map((v) => v + 1), new Uint8Array());
   });
 });
 
-describe('Reduce tests', () => {
+describe('Reduce method tests', () => {
   it('Reduce buffer', () => {
     const buf = new DynamicBuffer('abc');
 
-    const ret = buf.reduce((prev, cur) => prev + (cur - 97));
-
+    let ret = buf.reduce((prev, cur) => prev + (cur - 97));
     assert.equal(ret, 100);
-  });
-
-  it('Reduce buffer with initial value', () => {
-    const buf = new DynamicBuffer('abc');
-
-    const ret = buf.reduce((prev, cur) => prev + (cur - 97), 0);
 
+    ret = buf.reduce((prev, cur) => prev + (cur - 97), 0);
     assert.equal(ret, 3);
   });
 
@@ -170,37 +139,26 @@ describe('Reduce tests', () => {
     });
   });
 
-  it('Reduce empty buffer without initial value', () => {
+  it('Reduce empty buffer', () => {
     const buf = new DynamicBuffer();
 
+    const ret = buf.reduce((prev, cur) => prev + (cur - 97), 0);
+    assert.equal(ret, 0);
+
     assert.throws(() => {
       buf.reduce((prev, cur) => prev + (cur - 97));
     });
   });
-
-  it('Reduce empty buffer with initial value', () => {
-    const buf = new DynamicBuffer();
-
-    const ret = buf.reduce((prev, cur) => prev + (cur - 97), 0);
-
-    assert.equal(ret, 0);
-  });
 });
 
-describe('ReduceRight tests', () => {
+describe('ReduceRight method tests', () => {
   it('ReduceRight buffer', () => {
     const buf = new DynamicBuffer('abc');
 
-    const ret = buf.reduceRight((prev, cur) => prev + (cur - 97));
-
+    let ret = buf.reduceRight((prev, cur) => prev + (cur - 97));
     assert.equal(ret, 100);
-  });
-
-  it('ReduceRight buffer with initial value', () => {
-    const buf = new DynamicBuffer('abc');
-
-    const ret = buf.reduceRight((prev, cur) => prev + (cur - 97), 0);
 
+    ret = buf.reduceRight((prev, cur) => prev + (cur - 97), 0);
     assert.equal(ret, 3);
   });
 
@@ -220,24 +178,19 @@ describe('ReduceRight tests', () => {
     });
   });
 
-  it('ReduceRight empty buffer without initial value', () => {
+  it('ReduceRight empty buffer', () => {
     const buf = new DynamicBuffer();
 
+    const ret = buf.reduceRight((prev, cur) => prev + (cur - 97), 0);
+    assert.equal(ret, 0);
+
     assert.throws(() => {
       buf.reduceRight((prev, cur) => prev + (cur - 97));
     });
   });
-
-  it('ReduceRight empty buffer with initial value', () => {
-    const buf = new DynamicBuffer();
-
-    const ret = buf.reduceRight((prev, cur) => prev + (cur - 97), 0);
-
-    assert.equal(ret, 0);
-  });
 });
 
-describe('Reverse tests', () => {
+describe('Reverse method tests', () => {
   it('Reverse buffer', () => {
     const buf = new DynamicBuffer('hello');
     const ref = buf.reverse();
@@ -255,38 +208,29 @@ describe('Reverse tests', () => {
   });
 });
 
-describe('Some tests', () => {
-  it('Test some', () => {
+describe('Some method tests', () => {
+  it('Test some method', () => {
     const buf1 = new DynamicBuffer('HELLO');
-    const buf2 = new DynamicBuffer('Hello');
-
     assert.equal(buf1.some((v) => v >= 97 && v <= 122), false);
-    assert.equal(buf2.some((v) => v >= 97 && v <= 122), true);
-  });
 
-  it('Test empty buffer\'s some method', () => {
-    const buf = new DynamicBuffer();
+    const buf2 = new DynamicBuffer('Hello');
+    assert.equal(buf2.some((v) => v >= 97 && v <= 122), true);
 
-    assert.equal(buf.some((v) => v >= 97 && v <= 122), false);
+    const empty = new DynamicBuffer();
+    assert.equal(empty.some((v) => v >= 97 && v <= 122), false);
   });
 });
 
-describe('Sort tests', () => {
-  it('Sort without compare function', () => {
+describe('Sort method tests', () => {
+  it('Test sort method', () => {
     const buf = new DynamicBuffer('cba');
-    buf.sort();
+    buf.sort(); // without compare function
     assert.equal(buf.toString(), 'abc');
-  });
 
-  it('Sort in ascending order', () => {
-    const buf = new DynamicBuffer('cba');
-    buf.sort((a, b) => a - b);
-    assert.equal(buf.toString(), 'abc');
-  });
-
-  it('Sort in descending order', () => {
-    const buf = new DynamicBuffer('abc');
-    buf.sort((a, b) => b - a);
+    buf.sort((a, b) => b - a); // sort in descending order
     assert.equal(buf.toString(), 'cba');
+
+    buf.sort((a, b) => a - b); // sort in ascending order
+    assert.equal(buf.toString(), 'abc');
   });
 });