Additional tests

Author: EvidentlyCube

src/BinaryReader.ts

@@ -49,14 +49,12 @@ export class BinaryReader {
  * Trying to set it to value larger than `length` will set it to `length` instead (the end of the stream).
  */
 public set position(value: number) {
-if (typeof value !== 'number') {
-throw new InvalidArgumentError("Cannot set position to a value that is not a number", 'position', value);
-
-} else if (Number.isNaN(value)) {
-throw new InvalidArgumentError("Cannot set position to NaN", 'position', value);
-
-} else if (!Number.isFinite(value)) {
-throw new InvalidArgumentError("Cannot set position to infinite", 'position', value);
+if (
+typeof value !== 'number'
+|| Number.isNaN(value)
+|| !Number.isFinite(value)
+) {
+throw new InvalidArgumentError("Cannot set position to a non-numeric value", 'position', value);
 }
 
 this._position = Math.max(0, Math.min(this._view.length, value));
@@ -106,7 +104,7 @@ export class BinaryReader {
 this._view = new Uint8Array(stream);
 
 } else {
-throw new InvalidArgumentError("Stream is neither instance of ArrayBuffer nor Uint8Array.", 'stream', stream);
+throw new InvalidArgumentError("`stream` must be either an instance of ArrayBuffer or Uint8Array", 'stream', stream);
 }
 
 this.endianness = endianness;
@@ -547,10 +545,7 @@ export class BinaryReader {
 
 charactersToRead = Math.floor(charactersToRead);
 
-if (charactersToRead < 1) {
-return "";
-
-} else if (this.remainingBytes === 0) {
+if (this.remainingBytes === 0) {
 throw new EndOfStreamError(EndOfStreamMessageFactory.readCharZeroBytesLeft());
 }
 
@@ -586,10 +581,7 @@ export class BinaryReader {
 
 bytesToRead = Math.floor(bytesToRead);
 
-if (bytesToRead < 1) {
-return "";
-
-} else if (this.remainingBytes === 0) {
+if (this.remainingBytes === 0) {
 throw new EndOfStreamError(EndOfStreamMessageFactory.readCharZeroBytesLeft());
 }
 

src/BinaryWriter.ts

@@ -71,13 +71,11 @@ export class BinaryWriter {
 }
 
 public set endianness(value: Endianness) {
-if (this._endianness !== value) {
-if (!isValidEndianness(value)) {
-throw new InvalidArgumentError('`endianness` must be a value from the Endianness enum', 'endianness', value);
-}
-
-this._endianness = value;
+if (!isValidEndianness(value)) {
+throw new InvalidArgumentError('`endianness` must be a value from the Endianness enum', 'endianness', value);
 }
+
+this._endianness = value;
 }
 
 /**

test/BinaryReader.negatives.common.test.ts

@@ -1,12 +1,33 @@
 import { expect } from 'chai';
 import { BinaryReader } from "../src";
-import { getBufferOfLength } from "./common";
+import { getBufferOfLength, getInvalidNumberValues } from "./common";
+import { expectInvalidArgument } from './asserts';
 
 describe("BinaryReader, negative common tests", () => {
 describe('Constructor', () => {
 it("Throw exception when receiving invalid constructor", () => {
-// @ts-expect-error: Negative scenario checking
-expect(() => new BinaryReader(null)).to.throw();
+const invalidValues = [
+null,
+undefined,
+{},
+[],
+false,
+true,
+0,
+"",
+"0",
+function () { }
+];
+
+for (const value of invalidValues) {
+expectInvalidArgument(
+// @ts-expect-error: Negative scenario checking
+() => new BinaryReader(value),
+"`stream` must be either an instance of ArrayBuffer or Uint8Array",
+'stream',
+value
+);
+}
 // @ts-expect-error: Negative scenario checking
 expect(() => new BinaryReader(undefined)).to.throw();
 // @ts-expect-error: Negative scenario checking
@@ -24,26 +45,19 @@ describe("BinaryReader, negative common tests", () => {
 
 describe('Properties', () => {
 describe('set position', () => {
-it('Throw an error when setting to non numeric values', () => {
-const reader = new BinaryReader(getBufferOfLength(16));
-
-expect(() => reader.position = Number.NaN).to.throw();
-expect(() => reader.position = Number.NEGATIVE_INFINITY).to.throw();
-expect(() => reader.position = Number.POSITIVE_INFINITY).to.throw();
+for (const [name, value] of Object.entries(getInvalidNumberValues())) {
+it(`position = ${name}`, () => {
+const reader = new BinaryReader(getBufferOfLength(16));
 
-// @ts-expect-error: Negative scenario checking
-expect(() => reader.position = null).to.throw();
-// @ts-expect-error: Negative scenario checking
-expect(() => reader.position = undefined).to.throw();
-// @ts-expect-error: Negative scenario checking
-expect(() => reader.position = "").to.throw();
-// @ts-expect-error: Negative scenario checking
-expect(() => reader.position = []).to.throw();
-// @ts-expect-error: Negative scenario checking
-expect(() => reader.position = {}).to.throw();
-// @ts-expect-error: Negative scenario checking
-expect(() => reader.position = function () { }).to.throw();
-});
+expectInvalidArgument(
+// @ts-expect-error: Negative scenario checking
+() => reader.position = value,
+"Cannot set position to a non-numeric value",
+'position',
+value
+);
+});
+}
 });
 });
 });

test/BinaryReader.negatives.numbers.test.ts

@@ -3,7 +3,7 @@ import { BinaryReader, Encoding, EndOfStreamError, InvalidUtf8CharacterError } f
 import { getBufferArray, getBufferBinary, getBufferHex, getBufferOfLength, getUtf8CharArray } from "./common";
 import * as Utf8 from "../src/Utf8";
 import { EndOfStreamMessageFactory, InvalidUtf8CharacterMessageFactory } from "../src/errors/ErrorMessageFactory";
-import { InvalidArgumentError } from "../src/errors/InvalidArgumentError";
+import { expectInvalidArgument } from './asserts';
 
 const lead2 = Utf8.leadingByteLength2Prefix;
 const lead3 = Utf8.leadingByteLength3Prefix;
@@ -426,7 +426,12 @@ describe("BinaryReader, number negative tests", () => {
 it("Should fail if trying to read negative bytes", () => {
 const reader = new BinaryReader(getBufferOfLength(0));
 
-expect(() => reader.readBytes(-1)).to.throw(InvalidArgumentError);
+expectInvalidArgument(
+() => reader.readBytes(-1),
+'Cannot read less than 0 bytes',
+'bytesToRead',
+-1
+);
 });
 })
 });

test/BinaryReader.negatives.utf8.test.ts

@@ -268,7 +268,7 @@ describe("BinaryReader, string UTF-8 encoding negative tests", () => {
 
 describe('InvalidArguments - charactersToRead', () => {
 for (const [name, value] of Object.entries(getInvalidNumberValues())) {
-it(`readChar(${name}) - throw InvalidArgument exception`, () => {
+it(`readChars(${name}) - throw InvalidArgument exception`, () => {
 const reader = new BinaryReader(getBufferArray([]));
 
 expectInvalidArgument(

test/BinaryWriter.endianness.test.ts

@@ -4,7 +4,7 @@ import { Endianness } from '../src/Endianness';
 import { arrayToHex } from "./common";
 
 
-type ReadNumberTestCase = [(reader: BinaryWriter, value: number) => void, number, number, string|[string, string]];
+type ReadNumberTestCase = [(reader: BinaryWriter, value: number) => void, number, number, string | [string, string]];
 type ReadStringTestCase = [(reader: BinaryWriter, value: string) => void, string, string, string];
 
 describe("BinaryWriter, endianness", () => {
@@ -16,6 +16,7 @@ describe("BinaryWriter, endianness", () => {
 writeUnsignedInt: [(r, v) => r.writeUnsignedInt(v), 3506438151, 117440721, '07 00 00 D1'],
 writeInt: [(r, v) => r.writeInt(v), -788397817, 117506769, '07 01 02 D1'],
 writeFloat: [(r, v) => r.writeFloat(v), 3.355545997619629, 1546.6953125, '44 C1 56 40'],
+writeFloatNaN: [(r, v) => r.writeFloat(v), Number.NaN, Number.NaN, ['00 00 C0 FF', 'FF C0 00 00']],
 
 
 // Long stores values larger than float/double precision allows so unlike other tests we need

test/asserts.ts

@@ -10,6 +10,7 @@ export function expectInvalidArgument(callback: () => void, message: string, arg
 expect(unknownError).to.instanceOf(InvalidArgumentError);
 
 const err = unknownError as InvalidArgumentError;
+expect(err.message).to.equal(message);
 expect(err.argumentName).to.equal(argumentName);
 
 if (typeof argumentValue === 'number' && Number.isNaN(argumentValue)) {