From 09af2a253850a3276d3f1206ad10040678da264a Mon Sep 17 00:00:00 2001
From: Joshua Tenner <tenner.joshua@gmail.com>
Date: Fri, 19 Jul 2019 16:27:56 -0400
Subject: [PATCH] [Implement] Buffer.compare

---
 assembly/buffer/index.ts | 10 ++++++++++
 assembly/node.d.ts       |  2 ++
 tests/buffer.spec.ts     | 19 +++++++++++++++++++
 tests/node.js            |  4 ++++
 4 files changed, 35 insertions(+)

diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts
index 66866bf..51f66eb 100644
--- a/assembly/buffer/index.ts
+++ b/assembly/buffer/index.ts
@@ -22,4 +22,14 @@ export class Buffer extends Uint8Array {
     result.dataLength = size;
     return result;
   }
+
+  public static readonly compare: (a: Buffer, b: Buffer) => i32 = (a: Buffer, b: Buffer): i32 => {
+    let compareLength = min<i32>(a.length, b.length);
+    let result = memory.compare(a.dataStart, b.dataStart, compareLength);
+    if (result == 0) {
+      return a.length - b.length;
+    } else {
+      return result;
+    }
+  };
 }
diff --git a/assembly/node.d.ts b/assembly/node.d.ts
index 80075a8..ed81f06 100644
--- a/assembly/node.d.ts
+++ b/assembly/node.d.ts
@@ -3,4 +3,6 @@ declare class Buffer extends Uint8Array {
   static alloc(size: i32): Buffer;
   /** This method allocates a new Buffer of indicated size. This is unsafe because the data is not zeroed. */
   static allocUnsafe(size: i32): Buffer;
+  /** This method is used for sorting Buffer objects. */
+  static compare(a: Buffer, b: Buffer): i32;
 }
diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
index 1596845..fed7bca 100644
--- a/tests/buffer.spec.ts
+++ b/tests/buffer.spec.ts
@@ -1,3 +1,10 @@
+function instantiateFrom<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;
+}
+
 /**
  * This is the buffer test suite. For each prototype function, put a single test
  * function call here.
@@ -42,4 +49,16 @@ describe("buffer", () => {
     // TODO: expectFn(() => { Buffer.allocUnsafe(-1); }).toThrow();
     // TODO: expectFn(() => { Buffer.allocUnsafe(BLOCK_MAXSIZE + 1); }).toThrow();
   });
+
+  test("#compare", () => {
+    let a = instantiateFrom<Buffer>([0x05, 0x06, 0x07, 0x08]);
+    let b = instantiateFrom<Buffer>([0x01, 0x02, 0x03]);
+    let c = instantiateFrom<Buffer>([0x05, 0x06, 0x07]);
+    let d = instantiateFrom<Buffer>([0x04, 0x05, 0x06]);
+
+    let actual: Buffer[] = [a, b, c, d];
+    actual.sort(Buffer.compare);
+    let expected: Buffer[] = [b, d, c, a];
+    expect<Buffer[]>(actual).toStrictEqual(expected);
+  });
 });
diff --git a/tests/node.js b/tests/node.js
index 5117ef9..85bb458 100644
--- a/tests/node.js
+++ b/tests/node.js
@@ -153,3 +153,7 @@ function runTest(file, type, binary, wat) {
   wasi.view = new DataView(wasm.memory.buffer);
   context.run(wasm);
 }
+
+if (errors.length > 0) {
+  process.exit(1);
+}