[Implement] Buffer.compare

Author: jtenner

assembly/buffer/index.ts

@@ -22,4 +22,14 @@ export class Buffer extends Uint8Array {
     result.dataLength = size;
     return result;
   }
+
+  public static compare(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;
+    }
+  }
 }

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;
 }

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);
+  });
 });