test: add test cases for readXxx methods.

Author: ghosind

src/dynamicBuffer.ts

@@ -1015,7 +1015,7 @@ export class DynamicBuffer {
    * @param byteLength Number of bytes to read, and it must satisfy `0 < byteLength <= 6`.
    * @returns Integer read from the buffer at the specified offset.
    */
-  readIntLE(offset: number, byteLength: number) {
+  readIntLE(offset: number, byteLength: number): number {
     if (!this.buffer || this.length < byteLength) {
       throw new RangeError('Attempt to access memory outside buffer bounds');
     }

test/read.spec.ts

@@ -63,3 +63,100 @@ describe('At tests', () => {
     assert.equal(buffer.at(-str.length - 1), undefined);
   });
 });
+
+describe('More read test', () => {
+  it('Test read big int from buffer', () => {
+    const buf = new DynamicBuffer();
+
+    buf[4] = 0xff;
+    buf[5] = 0xff;
+    buf[6] = 0xff;
+    buf[7] = 0xff;
+    // 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
+
+    assert.equal(buf.readBigInt64BE(), 4294967295n);
+    assert.equal(buf.readBigInt64LE(), -4294967296n);
+    assert.equal(buf.readBigUInt64BE(), 4294967295n);
+    assert.equal(buf.readBigUInt64LE(), 18446744069414584320n);
+  });
+
+  it('Test read double and float from buffer', () => {
+    const buf = new DynamicBuffer();
+
+    for (let i = 0; i < 8; i += 1) {
+      buf[i] = i + 1;
+    }
+
+    assert.equal(buf.readDoubleBE(), 8.20788039913184e-304);
+    assert.equal(buf.readDoubleLE(), 5.447603722011605e-270);
+    assert.equal(buf.readFloatBE(), 2.387939260590663e-38);
+    assert.equal(buf.readFloatLE(), 1.539989614439558e-36);
+  });
+
+  it('Test read int from buffer', () => {
+    const buf = new DynamicBuffer();
+    buf[0] = 0x12;
+    buf[1] = 0x34;
+    buf[2] = 0x56;
+    buf[3] = 0x78;
+    buf[4] = 0x90;
+    buf[5] = 0xab;
+
+    const be = [0x12, 0x1234, 0x123456, 0x12345678, 0x1234567890, 0x1234567890ab];
+    const le = [0x12, 0x3412, 0x563412, 0x78563412, 0x9078563412, 0xab9078563412];
+
+    assert.equal(buf.readInt8(), be[0]);
+    assert.equal(buf.readInt16BE(), be[1]);
+    assert.equal(buf.readInt16LE(), le[1]);
+    assert.equal(buf.readInt32BE(), be[3]);
+    assert.equal(buf.readInt32LE(), le[3]);
+
+    assert.equal(buf.readUInt8(), be[0]);
+    assert.equal(buf.readUInt16BE(), be[1]);
+    assert.equal(buf.readUInt16LE(), le[1]);
+    assert.equal(buf.readUInt32BE(), be[3]);
+    assert.equal(buf.readUInt32LE(), le[3]);
+
+    for (let i = 1; i <= 6; i += 1) {
+      assert.equal(buf.readIntBE(0, i), be[i - 1]);
+      assert.equal(buf.readUIntBE(0, i), be[i - 1]);
+      assert.equal(buf.readUIntLE(0, i), le[i - 1]);
+
+      if (i === 5) {
+        assert.equal(buf.readIntLE(0, i), -479017421806);
+      } else if (i === 6) {
+        assert.equal(buf.readIntLE(0, i), -92837994154990);
+      } else {
+        assert.equal(buf.readIntLE(0, i), le[i - 1]);
+      }
+    }
+  });
+
+  it('Test read empty buffer', () => {
+    const buf = new DynamicBuffer();
+
+    assert.throws(() => buf.readBigInt64BE());
+    assert.throws(() => buf.readBigInt64LE());
+    assert.throws(() => buf.readBigUInt64BE());
+    assert.throws(() => buf.readBigUInt64LE());
+    assert.throws(() => buf.readDoubleBE());
+    assert.throws(() => buf.readDoubleLE());
+    assert.throws(() => buf.readFloatBE());
+    assert.throws(() => buf.readFloatLE());
+    assert.throws(() => buf.readInt8());
+    assert.throws(() => buf.readInt16BE());
+    assert.throws(() => buf.readInt16LE());
+    assert.throws(() => buf.readInt32BE());
+    assert.throws(() => buf.readInt32LE());
+    assert.throws(() => buf.readUInt8());
+    assert.throws(() => buf.readUInt16BE());
+    assert.throws(() => buf.readUInt16LE());
+    assert.throws(() => buf.readUInt32BE());
+    assert.throws(() => buf.readUInt32LE());
+
+    assert.throws(() => buf.readIntBE(0, 6));
+    assert.throws(() => buf.readIntLE(0, 6));
+    assert.throws(() => buf.readUIntBE(0, 6));
+    assert.throws(() => buf.readUIntLE(0, 6));
+  });
+});