From c21342973a75e54f6d1aad2654c73d6bd830f686 Mon Sep 17 00:00:00 2001
From: RedDwarfian <reddwarf86esb@gmail.com>
Date: Mon, 22 Jul 2019 21:35:41 -0400
Subject: [PATCH 1/9] [Implement] ReadInt16BE and ReadInt16LE

---
 assembly/buffer/index.ts | 10 ++++++++++
 assembly/node.d.ts       |  4 ++++
 tests/buffer.spec.ts     | 27 +++++++++++++++++++++++++++
 3 files changed, 41 insertions(+)

diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts
index 769dd8a..6ffa394 100644
--- a/assembly/buffer/index.ts
+++ b/assembly/buffer/index.ts
@@ -44,4 +44,14 @@ export class Buffer extends Uint8Array {
     if(<u32>offset >= this.dataLength) throw new RangeError(E_INDEXOUTOFRANGE);
     return load<i8>(this.dataStart + usize(offset));
   }
+
+  readInt16LE(offset: i32 = 0): i16 {
+    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<i16>(this.dataStart + usize(offset));
+  }
+
+  readInt16BE(offset: i32 = 0): i16 {
+    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    return bswap<i16>(load<i16>(this.dataStart + usize(offset)));
+  }
 }
diff --git a/assembly/node.d.ts b/assembly/node.d.ts
index 895ea93..9d5b4aa 100644
--- a/assembly/node.d.ts
+++ b/assembly/node.d.ts
@@ -11,4 +11,8 @@ declare class Buffer extends Uint8Array {
   writeInt8(value:i8, offset?:i32): i32;
   /** Reads a signed integer at the designated offset. */
   readInt8(offset?: i32): i8;
+  /** Reads a signed 16-bit integer, stored in Little Endian format at the designated offset. */
+  readInt16LE(offset?: i32): i16;
+  /** Reads a signed 16-bit integer, stored in Big Endian format at the designated offset. */
+  readInt16BE(offset?: i32): i16;
 }
diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index 9ba33fe..1db3429 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -89,4 +89,31 @@ describe("buffer", () => {
     //   newBuff.readInt8(5);
     // }).toThrow();
   });
+
+  test("#readInt16LE", () => {
+    let buff = new Buffer(10);
+    buff[0] = 0;
+    buff[1] = 5;
+    buff[2] = 0;
+    expect<i16>(buff.readInt16LE()).toBe(1280);
+    expect<i16>(buff.readInt16LE(1)).toBe(5);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.readInt16LE(0);
+    // }).toThrow();
+  })
+  test("#readInt16BE", () => {
+    let buff = new Buffer(10);
+    buff[0] = 0;
+    buff[1] = 5;
+    buff[2] = 0;
+    expect<i16>(buff.readInt16BE()).toBe(5);
+    expect<i16>(buff.readInt16BE(1)).toBe(1280);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.readInt16BE(0);
+    // }).toThrow();
+  })
 });

From 82757c00e4aba68dcb3804817fc41a61c81f9e8c Mon Sep 17 00:00:00 2001
From: RedDwarfian <reddwarf86esb@gmail.com>
Date: Mon, 22 Jul 2019 21:40:22 -0400
Subject: [PATCH 2/9] [Cleanup] Consistent with std lib, Missing TODOs

---
 assembly/buffer/index.ts |  8 ++++----
 tests/buffer.spec.ts     | 10 ++++++++++
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts
index 6ffa394..34b1dbe 100644
--- a/assembly/buffer/index.ts
+++ b/assembly/buffer/index.ts
@@ -25,7 +25,7 @@ export class Buffer extends Uint8Array {
 
   readUInt8(offset: i32 = 0): u8 {
     if(<u32>offset >= this.dataLength) throw new RangeError(E_INDEXOUTOFRANGE);
-    return load<u8>(this.dataStart + usize(offset));
+    return load<u8>(this.dataStart + <usize>offset);
   }
 
   writeUInt8(value: u8, offset: i32 = 0): i32 {
@@ -42,16 +42,16 @@ export class Buffer extends Uint8Array {
   
   readInt8(offset: i32 = 0): i8 {
     if(<u32>offset >= this.dataLength) throw new RangeError(E_INDEXOUTOFRANGE);
-    return load<i8>(this.dataStart + usize(offset));
+    return load<i8>(this.dataStart + <usize>offset);
   }
 
   readInt16LE(offset: i32 = 0): i16 {
     if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
-    return load<i16>(this.dataStart + usize(offset));
+    return load<i16>(this.dataStart + <usize>offset);
   }
 
   readInt16BE(offset: i32 = 0): i16 {
     if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
-    return bswap<i16>(load<i16>(this.dataStart + usize(offset)));
+    return bswap<i16>(load<i16>(this.dataStart + <usize>offset));
   }
 }
diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index 1db3429..78439ec 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -65,6 +65,11 @@ describe("buffer", () => {
     expect<i32>(buff.writeUInt8(252,4)).toBe(5);
     expect<u8>(buff[0]).toBe(4);
     expect<u8>(buff[4]).toBe(252);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.writeUInt8(5,10);
+    // }).toThrow();    
   });  
 
   test("#writeInt8", () => {
@@ -73,6 +78,11 @@ describe("buffer", () => {
     expect<i32>(buff.writeInt8(-3,4)).toBe(5);
     expect<i8>(buff[0]).toBe(9);
     expect<i8>(buff[4]).toBe(-3);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.writeInt8(5,10);
+    // }).toThrow();    
   });
 
   test("#readInt8", () => {

From 0c3cb745d23ad76e14f64fb76039d762ce5ec3bf Mon Sep 17 00:00:00 2001
From: RedDwarfian <reddwarf86esb@gmail.com>
Date: Mon, 22 Jul 2019 23:13:14 -0400
Subject: [PATCH 3/9] [Implement] ReadUInt16BE and ReadUInt16LE

---
 assembly/buffer/index.ts | 11 +++++++++++
 assembly/node.d.ts       |  4 ++++
 tests/buffer.spec.ts     | 26 ++++++++++++++++++++++++++
 3 files changed, 41 insertions(+)

diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts
index 34b1dbe..2fb4d0c 100644
--- a/assembly/buffer/index.ts
+++ b/assembly/buffer/index.ts
@@ -54,4 +54,15 @@ export class Buffer extends Uint8Array {
     if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
     return bswap<i16>(load<i16>(this.dataStart + <usize>offset));
   }
+
+  readUInt16LE(offset: i32 = 0): u16 {
+    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<u16>(this.dataStart + <usize>offset);
+  }
+
+  readUInt16BE(offset: i32 = 0): u16 {
+    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    return bswap<u16>(load<u16>(this.dataStart + <usize>offset));
+  }
+
 }
diff --git a/assembly/node.d.ts b/assembly/node.d.ts
index 9d5b4aa..a839197 100644
--- a/assembly/node.d.ts
+++ b/assembly/node.d.ts
@@ -15,4 +15,8 @@ declare class Buffer extends Uint8Array {
   readInt16LE(offset?: i32): i16;
   /** Reads a signed 16-bit integer, stored in Big Endian format at the designated offset. */
   readInt16BE(offset?: i32): i16;
+  /** Reads an unsigned 16-bit integer, stored in Little Endian format at the designated offset. */
+  readIntU16LE(offset?: i32): u16;
+  /** Reads an unsigned 16-bit integer, stored in Big Endian format at the designated offset. */
+  readIntU16BE(offset?: i32): u16;
 }
diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index 78439ec..dccefbf 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -126,4 +126,30 @@ describe("buffer", () => {
     //   newBuff.readInt16BE(0);
     // }).toThrow();
   })
+  test("#readUInt16LE", () => {
+    let buff = new Buffer(10);
+    buff[0] = 0;
+    buff[1] = 5;
+    buff[2] = 0;
+    expect<u16>(buff.readUInt16LE()).toBe(1280);
+    expect<u16>(buff.readUInt16LE(1)).toBe(5);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.readUInt16LE(0);
+    // }).toThrow();
+  })
+  test("#readUInt16BE", () => {
+    let buff = new Buffer(10);
+    buff[0] = 0;
+    buff[1] = 5;
+    buff[2] = 0;
+    expect<i16>(buff.readUInt16BE()).toBe(5);
+    expect<i16>(buff.readUInt16BE(1)).toBe(1280);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.readUInt16BE(0);
+    // }).toThrow();
+  })
 });

From 583d752cff73a3aa1636104c7a65770a998089e6 Mon Sep 17 00:00:00 2001
From: RedDwarfian <reddwarf86esb@gmail.com>
Date: Tue, 23 Jul 2019 21:43:23 -0400
Subject: [PATCH 4/9] [Implement] write(U)Int(L/B)E

---
 assembly/buffer/index.ts | 23 +++++++++++++++
 assembly/node.d.ts       | 12 ++++++--
 tests/buffer.spec.ts     | 60 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts
index 2fb4d0c..528e1f9 100644
--- a/assembly/buffer/index.ts
+++ b/assembly/buffer/index.ts
@@ -65,4 +65,27 @@ export class Buffer extends Uint8Array {
     return bswap<u16>(load<u16>(this.dataStart + <usize>offset));
   }
 
+  writeInt16LE(value: i16, offset: i32 = 0): i32 {
+    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i16>(this.dataStart + offset, value);
+    return offset + 2;
+  }
+
+  writeInt16BE(value: i16, offset: i32 = 0): i32 {
+    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i16>(this.dataStart + offset, bswap<i16>(value));
+    return offset + 2;
+  }
+
+  writeUInt16LE(value: u16, offset: i32 = 0): i32 {
+    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u16>(this.dataStart + offset, value);
+    return offset + 2;
+  }
+
+  writeUInt16BE(value: u16, offset: i32 = 0): i32 {
+    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u16>(this.dataStart + offset, bswap<u16>(value));
+    return offset + 2;
+  }
 }
diff --git a/assembly/node.d.ts b/assembly/node.d.ts
index a839197..5009503 100644
--- a/assembly/node.d.ts
+++ b/assembly/node.d.ts
@@ -16,7 +16,15 @@ declare class Buffer extends Uint8Array {
   /** Reads a signed 16-bit integer, stored in Big Endian format at the designated offset. */
   readInt16BE(offset?: i32): i16;
   /** Reads an unsigned 16-bit integer, stored in Little Endian format at the designated offset. */
-  readIntU16LE(offset?: i32): u16;
+  readUInt16LE(offset?: i32): u16;
   /** Reads an unsigned 16-bit integer, stored in Big Endian format at the designated offset. */
-  readIntU16BE(offset?: i32): u16;
+  readUInt16BE(offset?: i32): u16;
+  /** Writes an inputted 16-bit integer at the designated offset, stored in Little Endian format */
+  writeInt16LE(value: i16, offset?: i32): i32;
+  /** Writes an inputted 16-bit integer at the designated offset, stored in Big Endian format */
+  writeInt16BE(value: i16, offset?: i32): i32;
+  /** Writes an inputted unsigned 16-bit integer at the designated offset, stored in Little Endian format */
+  writeUInt16LE(value: u16, offset?: i32): i32;
+  /** Writes an inputted unsigned 16-bit integer at the designated offset, stored in Big Endian format */
+  writeUInt16BE(value: u16, offset?: i32): i32;
 }
diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index dccefbf..c448702 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -113,6 +113,7 @@ describe("buffer", () => {
     //   newBuff.readInt16LE(0);
     // }).toThrow();
   })
+
   test("#readInt16BE", () => {
     let buff = new Buffer(10);
     buff[0] = 0;
@@ -126,6 +127,7 @@ describe("buffer", () => {
     //   newBuff.readInt16BE(0);
     // }).toThrow();
   })
+
   test("#readUInt16LE", () => {
     let buff = new Buffer(10);
     buff[0] = 0;
@@ -139,6 +141,7 @@ describe("buffer", () => {
     //   newBuff.readUInt16LE(0);
     // }).toThrow();
   })
+
   test("#readUInt16BE", () => {
     let buff = new Buffer(10);
     buff[0] = 0;
@@ -152,4 +155,61 @@ describe("buffer", () => {
     //   newBuff.readUInt16BE(0);
     // }).toThrow();
   })
+
+  test("#writeInt16LE", () => {
+    let buff = new Buffer(4);
+    expect<i32>(buff.writeInt16LE(5)).toBe(2);
+    expect<i32>(buff.writeInt16LE(1280,2)).toBe(4);
+    expect<i8>(buff[0]).toBe(5);
+    expect<i8>(buff[1]).toBe(0);
+    expect<i8>(buff[2]).toBe(0);
+    expect<i8>(buff[3]).toBe(5);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.writeInt16LE(0);
+    // }).toThrow();
+  })
+  test("#writeInt16BE", () => {
+    let buff = new Buffer(4);
+    expect<i32>(buff.writeInt16BE(1280)).toBe(2);
+    expect<i32>(buff.writeInt16BE(5,2)).toBe(4);
+    expect<i8>(buff[0]).toBe(5);
+    expect<i8>(buff[1]).toBe(0);
+    expect<i8>(buff[2]).toBe(0);
+    expect<i8>(buff[3]).toBe(5);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.writeInt16BE(0);
+    // }).toThrow();
+  })
+  test("#writeUInt16LE", () => {
+    let buff = new Buffer(4);
+    expect<i32>(buff.writeUInt16LE(5)).toBe(2);
+    expect<i32>(buff.writeUInt16LE(1280,2)).toBe(4);
+    expect<i8>(buff[0]).toBe(5);
+    expect<i8>(buff[1]).toBe(0);
+    expect<i8>(buff[2]).toBe(0);
+    expect<i8>(buff[3]).toBe(5);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.writeUInt16LE(0);
+    // }).toThrow();
+  })
+  test("#writeUInt16BE", () => {
+    let buff = new Buffer(4);
+    expect<i32>(buff.writeUInt16BE(1280)).toBe(2);
+    expect<i32>(buff.writeUInt16BE(5,2)).toBe(4);
+    expect<i8>(buff[0]).toBe(5);
+    expect<i8>(buff[1]).toBe(0);
+    expect<i8>(buff[2]).toBe(0);
+    expect<i8>(buff[3]).toBe(5);
+    // TODO:
+    // expectFn(() => { 
+    //   let newBuff = new Buffer(1);
+    //   newBuff.writeUInt16BE(0);
+    // }).toThrow();
+  })
 });

From 269f1c8c2c8d3f6ea2d113476f10e1f96de66a11 Mon Sep 17 00:00:00 2001
From: RedDwarfian <reddwarf86esb@gmail.com>
Date: Wed, 24 Jul 2019 20:52:51 -0400
Subject: [PATCH 5/9] [Cleanup] [Optimize] Using recommended changes

---
 assembly/buffer/index.ts | 38 +++++++++++++++++++-------------------
 assembly/node.d.ts       |  8 ++++----
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts
index 9374b94..fb5d4ca 100644
--- a/assembly/buffer/index.ts
+++ b/assembly/buffer/index.ts
@@ -27,68 +27,68 @@ export class Buffer extends Uint8Array {
     return value instanceof Buffer;
   }
 
-  readUInt8(offset: i32 = 0): u8 {
-    if(<u32>offset >= this.dataLength) throw new RangeError(E_INDEXOUTOFRANGE);
-    return load<u8>(this.dataStart + <usize>offset);
+  readInt8(offset: i32 = 0): i8 {
+    if(i32(offset < 0) | i32(<u32>offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<i8>(this.dataStart + <usize>offset);
   }
 
-  writeUInt8(value: u8, offset: i32 = 0): i32 {
-    if(<u32>offset >= this.dataLength) throw new RangeError(E_INDEXOUTOFRANGE);
-    store<u8>(this.dataStart + offset, value);
-    return offset + 1;
+  readUInt8(offset: i32 = 0): u8 {
+    if(i32(offset < 0) | i32(<u32>offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<u8>(this.dataStart + <usize>offset);
   }
 
   writeInt8(value: i8, offset: i32 = 0): i32 {
-    if(<u32>offset >= this.dataLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     store<i8>(this.dataStart + offset, value);
     return offset + 1;
   }
 
-  readInt8(offset: i32 = 0): i8 {
-    if(<u32>offset >= this.dataLength) throw new RangeError(E_INDEXOUTOFRANGE);
-    return load<i8>(this.dataStart + <usize>offset);
+  writeUInt8(value: u8, offset: i32 = 0): i32 {
+    if(i32(offset < 0) | i32(<u32>offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u8>(this.dataStart + offset, value);
+    return offset + 1;
   }
 
   readInt16LE(offset: i32 = 0): i16 {
-    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     return load<i16>(this.dataStart + <usize>offset);
   }
 
   readInt16BE(offset: i32 = 0): i16 {
-    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     return bswap<i16>(load<i16>(this.dataStart + <usize>offset));
   }
 
   readUInt16LE(offset: i32 = 0): u16 {
-    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     return load<u16>(this.dataStart + <usize>offset);
   }
 
   readUInt16BE(offset: i32 = 0): u16 {
-    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     return bswap<u16>(load<u16>(this.dataStart + <usize>offset));
   }
 
   writeInt16LE(value: i16, offset: i32 = 0): i32 {
-    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     store<i16>(this.dataStart + offset, value);
     return offset + 2;
   }
 
   writeInt16BE(value: i16, offset: i32 = 0): i32 {
-    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     store<i16>(this.dataStart + offset, bswap<i16>(value));
     return offset + 2;
   }
 
   writeUInt16LE(value: u16, offset: i32 = 0): i32 {
-    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     store<u16>(this.dataStart + offset, value);
     return offset + 2;
   }
 
   writeUInt16BE(value: u16, offset: i32 = 0): i32 {
-    if(<u32>offset >= this.dataLength - 1) throw new RangeError(E_INDEXOUTOFRANGE);
+    if(i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
     store<u16>(this.dataStart + offset, bswap<u16>(value));
     return offset + 2;
   }
diff --git a/assembly/node.d.ts b/assembly/node.d.ts
index 6a6920d..5beb381 100644
--- a/assembly/node.d.ts
+++ b/assembly/node.d.ts
@@ -5,14 +5,14 @@ declare class Buffer extends Uint8Array {
   static allocUnsafe(size: i32): Buffer;
   /** This method asserts a value is a Buffer object via `value instanceof Buffer`. */
   static isBuffer<T>(value: T): bool;
+  /** Reads a signed integer at the designated offset. */
+  readInt8(offset?: i32): i8;
   /** Reads an unsigned integer at the designated offset. */
   readUInt8(offset?: i32): u8;
-  /** Writes an inputted u8 value to the buffer, at the desired offset. */
-  writeUInt8(value:u8, offset?:i32): i32;
   /** Writes an inputted value to the buffer, at the desired offset. */
   writeInt8(value:i8, offset?:i32): i32;
-  /** Reads a signed integer at the designated offset. */
-  readInt8(offset?: i32): i8;
+  /** Writes an inputted u8 value to the buffer, at the desired offset. */
+  writeUInt8(value:u8, offset?:i32): i32;
   /** Reads a signed 16-bit integer, stored in Little Endian format at the designated offset. */
   readInt16LE(offset?: i32): i16;
   /** Reads a signed 16-bit integer, stored in Big Endian format at the designated offset. */

From 60f09005f326114a29e83746af0bd5743fa13607 Mon Sep 17 00:00:00 2001
From: RedDwarfian <reddwarf86esb@gmail.com>
Date: Thu, 25 Jul 2019 21:09:42 -0400
Subject: [PATCH 6/9] [Cleanup] Directly comparing written buffers

---
 tests/buffer.spec.ts | 87 ++++++++++++++++++++++----------------------
 1 file changed, 44 insertions(+), 43 deletions(-)

diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index 983a94a..749612b 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -11,6 +11,15 @@
  */
 import { BLOCK_MAXSIZE } from "rt/common";
 
+// Helper function to quickly create a Buffer from an array.
+//@ts-ignore
+function create<T>(values: valueof<T>[]): T {
+  let result = instantiate<T>(values.length);
+  //@ts-ignore
+  for (let i = 0; i < values.length; i++) result[i] = values[i];
+  return result;
+}
+
 describe("buffer", () => {
   test("#constructor", () => {
     expect<Buffer>(new Buffer(0)).toBeTruthy();
@@ -58,6 +67,21 @@ describe("buffer", () => {
     expect<bool>(Buffer.isBuffer<Buffer | null>(null)).toBeFalsy();
   });
 
+  test("#readInt8", () => {
+    let buff = new Buffer(10);
+    buff[0] = 5;
+    buff[9] = 255;
+    expect<i8>(buff.readInt8(0)).toBe(5);
+    expect<i8>(buff.readInt8()).toBe(5);
+    // Testing offset, and casting between u8 and i8.
+    expect<i8>(buff.readInt8(9)).toBe(-1);
+    // TODO:
+    // expectFn(() => {
+    //   let newBuff = new Buffer(1);
+    //   newBuff.readInt8(5);
+    // }).toThrow();
+  });
+
   test("#readUInt8", () => {
     let buff = new Buffer(10);
     buff[0] = -2;
@@ -74,25 +98,12 @@ describe("buffer", () => {
     // }).toThrow();
   });
 
-  test("#writeUInt8", () => {
-    let buff = new Buffer(5);
-    expect<i32>(buff.writeUInt8(4)).toBe(1);
-    expect<i32>(buff.writeUInt8(252,4)).toBe(5);
-    expect<u8>(buff[0]).toBe(4);
-    expect<u8>(buff[4]).toBe(252);
-    // TODO:
-    // expectFn(() => { 
-    //   let newBuff = new Buffer(1);
-    //   newBuff.writeUInt8(5,10);
-    // }).toThrow();    
-  });  
-
   test("#writeInt8", () => {
     let buff = new Buffer(5);
     expect<i32>(buff.writeInt8(9)).toBe(1);
     expect<i32>(buff.writeInt8(-3,4)).toBe(5);
-    expect<i8>(buff[0]).toBe(9);
-    expect<i8>(buff[4]).toBe(-3);
+    let result = create<Buffer>([0x09, 0x0, 0x0, 0x0, 0xFD]);
+    expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
     // expectFn(() => { 
     //   let newBuff = new Buffer(1);
@@ -100,20 +111,18 @@ describe("buffer", () => {
     // }).toThrow();    
   });
 
-  test("#readInt8", () => {
-    let buff = new Buffer(10);
-    buff[0] = 5;
-    buff[9] = 255;
-    expect<i8>(buff.readInt8(0)).toBe(5);
-    expect<i8>(buff.readInt8()).toBe(5);
-    // Testing offset, and casting between u8 and i8.
-    expect<i8>(buff.readInt8(9)).toBe(-1);
+  test("#writeUInt8", () => {
+    let buff = new Buffer(5);
+    expect<i32>(buff.writeUInt8(4)).toBe(1);
+    expect<i32>(buff.writeUInt8(252,4)).toBe(5);
+    let result = create<Buffer>([0x04, 0x0, 0x0, 0x0, 0xFC]);
+    expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
-    // expectFn(() => {
+    // expectFn(() => { 
     //   let newBuff = new Buffer(1);
-    //   newBuff.readInt8(5);
-    // }).toThrow();
-  });
+    //   newBuff.writeUInt8(5,10);
+    // }).toThrow();    
+  });  
 
   test("#readInt16LE", () => {
     let buff = new Buffer(10);
@@ -175,10 +184,8 @@ describe("buffer", () => {
     let buff = new Buffer(4);
     expect<i32>(buff.writeInt16LE(5)).toBe(2);
     expect<i32>(buff.writeInt16LE(1280,2)).toBe(4);
-    expect<i8>(buff[0]).toBe(5);
-    expect<i8>(buff[1]).toBe(0);
-    expect<i8>(buff[2]).toBe(0);
-    expect<i8>(buff[3]).toBe(5);
+    let result = create<Buffer>([0x05, 0x0, 0x0, 0x5]);
+    expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
     // expectFn(() => { 
     //   let newBuff = new Buffer(1);
@@ -189,10 +196,8 @@ describe("buffer", () => {
     let buff = new Buffer(4);
     expect<i32>(buff.writeInt16BE(1280)).toBe(2);
     expect<i32>(buff.writeInt16BE(5,2)).toBe(4);
-    expect<i8>(buff[0]).toBe(5);
-    expect<i8>(buff[1]).toBe(0);
-    expect<i8>(buff[2]).toBe(0);
-    expect<i8>(buff[3]).toBe(5);
+    let result = create<Buffer>([0x05, 0x0, 0x0, 0x5]);
+    expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
     // expectFn(() => { 
     //   let newBuff = new Buffer(1);
@@ -203,10 +208,8 @@ describe("buffer", () => {
     let buff = new Buffer(4);
     expect<i32>(buff.writeUInt16LE(5)).toBe(2);
     expect<i32>(buff.writeUInt16LE(1280,2)).toBe(4);
-    expect<i8>(buff[0]).toBe(5);
-    expect<i8>(buff[1]).toBe(0);
-    expect<i8>(buff[2]).toBe(0);
-    expect<i8>(buff[3]).toBe(5);
+    let result = create<Buffer>([0x05, 0x0, 0x0, 0x5]);
+    expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
     // expectFn(() => { 
     //   let newBuff = new Buffer(1);
@@ -217,10 +220,8 @@ describe("buffer", () => {
     let buff = new Buffer(4);
     expect<i32>(buff.writeUInt16BE(1280)).toBe(2);
     expect<i32>(buff.writeUInt16BE(5,2)).toBe(4);
-    expect<i8>(buff[0]).toBe(5);
-    expect<i8>(buff[1]).toBe(0);
-    expect<i8>(buff[2]).toBe(0);
-    expect<i8>(buff[3]).toBe(5);
+    let result = create<Buffer>([0x05, 0x0, 0x0, 0x5]);
+    expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
     // expectFn(() => { 
     //   let newBuff = new Buffer(1);

From 529ab7f901126a63bd36f84effb770b454bc4b73 Mon Sep 17 00:00:00 2001
From: RedDwarfian <reddwarf86esb@gmail.com>
Date: Thu, 25 Jul 2019 21:54:39 -0400
Subject: [PATCH 7/9] [Cleanup] Increases tests readability and malleability

---
 tests/buffer.spec.ts | 34 ++++++++--------------------------
 1 file changed, 8 insertions(+), 26 deletions(-)

diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index 749612b..e8dc455 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -68,13 +68,10 @@ describe("buffer", () => {
   });
 
   test("#readInt8", () => {
-    let buff = new Buffer(10);
-    buff[0] = 5;
-    buff[9] = 255;
-    expect<i8>(buff.readInt8(0)).toBe(5);
+    let buff = create<Buffer>([0x5,0x0,0x0,0x0,0xFF]);
     expect<i8>(buff.readInt8()).toBe(5);
     // Testing offset, and casting between u8 and i8.
-    expect<i8>(buff.readInt8(9)).toBe(-1);
+    expect<i8>(buff.readInt8(4)).toBe(-1);
     // TODO:
     // expectFn(() => {
     //   let newBuff = new Buffer(1);
@@ -83,14 +80,11 @@ describe("buffer", () => {
   });
 
   test("#readUInt8", () => {
-    let buff = new Buffer(10);
-    buff[0] = -2;
-    buff[9] = 47;
+    let buff = create<Buffer>([0xFE,0x0,0x0,0x0,0x2F]);
     // Testing casting between u8 and i8.
-    expect<u8>(buff.readUInt8(0)).toBe(254);
     expect<u8>(buff.readUInt8()).toBe(254);
     // Testing offset
-    expect<u8>(buff.readUInt8(9)).toBe(47);
+    expect<u8>(buff.readUInt8(4)).toBe(47);
     // TODO:
     // expectFn(() => {
     //   let newBuff = new Buffer(1);
@@ -125,10 +119,7 @@ describe("buffer", () => {
   });  
 
   test("#readInt16LE", () => {
-    let buff = new Buffer(10);
-    buff[0] = 0;
-    buff[1] = 5;
-    buff[2] = 0;
+    let buff = create<Buffer>([0x0,0x05,0x0]);
     expect<i16>(buff.readInt16LE()).toBe(1280);
     expect<i16>(buff.readInt16LE(1)).toBe(5);
     // TODO:
@@ -139,10 +130,7 @@ describe("buffer", () => {
   })
 
   test("#readInt16BE", () => {
-    let buff = new Buffer(10);
-    buff[0] = 0;
-    buff[1] = 5;
-    buff[2] = 0;
+    let buff = create<Buffer>([0x0,0x05,0x0]);
     expect<i16>(buff.readInt16BE()).toBe(5);
     expect<i16>(buff.readInt16BE(1)).toBe(1280);
     // TODO:
@@ -153,10 +141,7 @@ describe("buffer", () => {
   })
 
   test("#readUInt16LE", () => {
-    let buff = new Buffer(10);
-    buff[0] = 0;
-    buff[1] = 5;
-    buff[2] = 0;
+    let buff = create<Buffer>([0x0,0x05,0x0]);
     expect<u16>(buff.readUInt16LE()).toBe(1280);
     expect<u16>(buff.readUInt16LE(1)).toBe(5);
     // TODO:
@@ -167,10 +152,7 @@ describe("buffer", () => {
   })
 
   test("#readUInt16BE", () => {
-    let buff = new Buffer(10);
-    buff[0] = 0;
-    buff[1] = 5;
-    buff[2] = 0;
+    let buff = create<Buffer>([0x0,0x05,0x0]);
     expect<i16>(buff.readUInt16BE()).toBe(5);
     expect<i16>(buff.readUInt16BE(1)).toBe(1280);
     // TODO:

From 1875babe7e2631823b8c19fd6b716fc5f012ded7 Mon Sep 17 00:00:00 2001
From: jtenner <tenner.joshua@gmail.com>
Date: Fri, 26 Jul 2019 10:09:23 -0400
Subject: [PATCH 8/9] [Cleanup] Formatting

---
 tests/buffer.spec.ts | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index e8dc455..81b3bbb 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -127,7 +127,7 @@ describe("buffer", () => {
     //   let newBuff = new Buffer(1);
     //   newBuff.readInt16LE(0);
     // }).toThrow();
-  })
+  });
 
   test("#readInt16BE", () => {
     let buff = create<Buffer>([0x0,0x05,0x0]);
@@ -138,7 +138,7 @@ describe("buffer", () => {
     //   let newBuff = new Buffer(1);
     //   newBuff.readInt16BE(0);
     // }).toThrow();
-  })
+  });
 
   test("#readUInt16LE", () => {
     let buff = create<Buffer>([0x0,0x05,0x0]);
@@ -149,7 +149,7 @@ describe("buffer", () => {
     //   let newBuff = new Buffer(1);
     //   newBuff.readUInt16LE(0);
     // }).toThrow();
-  })
+  });
 
   test("#readUInt16BE", () => {
     let buff = create<Buffer>([0x0,0x05,0x0]);
@@ -160,7 +160,7 @@ describe("buffer", () => {
     //   let newBuff = new Buffer(1);
     //   newBuff.readUInt16BE(0);
     // }).toThrow();
-  })
+  });
 
   test("#writeInt16LE", () => {
     let buff = new Buffer(4);
@@ -173,7 +173,8 @@ describe("buffer", () => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeInt16LE(0);
     // }).toThrow();
-  })
+  });
+
   test("#writeInt16BE", () => {
     let buff = new Buffer(4);
     expect<i32>(buff.writeInt16BE(1280)).toBe(2);
@@ -185,7 +186,8 @@ describe("buffer", () => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeInt16BE(0);
     // }).toThrow();
-  })
+  });
+
   test("#writeUInt16LE", () => {
     let buff = new Buffer(4);
     expect<i32>(buff.writeUInt16LE(5)).toBe(2);
@@ -197,7 +199,8 @@ describe("buffer", () => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeUInt16LE(0);
     // }).toThrow();
-  })
+  });
+
   test("#writeUInt16BE", () => {
     let buff = new Buffer(4);
     expect<i32>(buff.writeUInt16BE(1280)).toBe(2);
@@ -209,5 +212,5 @@ describe("buffer", () => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeUInt16BE(0);
     // }).toThrow();
-  })
+  });
 });

From a73594be1ffea8e96fe439ac1810ae466ba17076 Mon Sep 17 00:00:00 2001
From: jtenner <tenner.joshua@gmail.com>
Date: Fri, 26 Jul 2019 10:28:17 -0400
Subject: [PATCH 9/9] [Cleanup] commented toThrow() function formatting

---
 tests/buffer.spec.ts | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index 81b3bbb..ba4ff36 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -99,7 +99,7 @@ describe("buffer", () => {
     let result = create<Buffer>([0x09, 0x0, 0x0, 0x0, 0xFD]);
     expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeInt8(5,10);
     // }).toThrow();    
@@ -112,7 +112,7 @@ describe("buffer", () => {
     let result = create<Buffer>([0x04, 0x0, 0x0, 0x0, 0xFC]);
     expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeUInt8(5,10);
     // }).toThrow();    
@@ -123,7 +123,7 @@ describe("buffer", () => {
     expect<i16>(buff.readInt16LE()).toBe(1280);
     expect<i16>(buff.readInt16LE(1)).toBe(5);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.readInt16LE(0);
     // }).toThrow();
@@ -134,7 +134,7 @@ describe("buffer", () => {
     expect<i16>(buff.readInt16BE()).toBe(5);
     expect<i16>(buff.readInt16BE(1)).toBe(1280);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.readInt16BE(0);
     // }).toThrow();
@@ -145,7 +145,7 @@ describe("buffer", () => {
     expect<u16>(buff.readUInt16LE()).toBe(1280);
     expect<u16>(buff.readUInt16LE(1)).toBe(5);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.readUInt16LE(0);
     // }).toThrow();
@@ -156,7 +156,7 @@ describe("buffer", () => {
     expect<i16>(buff.readUInt16BE()).toBe(5);
     expect<i16>(buff.readUInt16BE(1)).toBe(1280);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.readUInt16BE(0);
     // }).toThrow();
@@ -169,7 +169,7 @@ describe("buffer", () => {
     let result = create<Buffer>([0x05, 0x0, 0x0, 0x5]);
     expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeInt16LE(0);
     // }).toThrow();
@@ -182,7 +182,7 @@ describe("buffer", () => {
     let result = create<Buffer>([0x05, 0x0, 0x0, 0x5]);
     expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeInt16BE(0);
     // }).toThrow();
@@ -195,7 +195,7 @@ describe("buffer", () => {
     let result = create<Buffer>([0x05, 0x0, 0x0, 0x5]);
     expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeUInt16LE(0);
     // }).toThrow();
@@ -208,7 +208,7 @@ describe("buffer", () => {
     let result = create<Buffer>([0x05, 0x0, 0x0, 0x5]);
     expect<Buffer>(buff).toStrictEqual(result);
     // TODO:
-    // expectFn(() => { 
+    // expectFn(() => {
     //   let newBuff = new Buffer(1);
     //   newBuff.writeUInt16BE(0);
     // }).toThrow();