Add unit test

Author: davidnguyen11

src/index.ts

@@ -3,20 +3,10 @@ import { IPriorityQueue } from "../typing/priority-queue";
 export class PriorityQueue<T> implements IPriorityQueue<T> {
   private queue: T[];
   private comparator: (item1: T, item2: T) => boolean;
-  private swapper: (index1: number, index2: number) => void;
-
-  constructor(
-    queue: T[] = [],
-    comparator?: (item1: T, item2: T) => boolean,
-    swapper?: (index1: number, index2: number) => void
-  ) {
-    this.queue = queue;
-    this.comparator = comparator;
-    this.swapper = swapper;
 
-    if (this.queue.length > 0) {
-      this._build();
-    }
+  constructor(comparator?: (item1: T, item2: T) => boolean) {
+    this.queue = [];
+    this.comparator = comparator;
   }
 
   /**
@@ -80,16 +70,6 @@ export class PriorityQueue<T> implements IPriorityQueue<T> {
     return [...this.queue];
   }
 
-  /**
-   * Build min or max heap
-   */
-  private _build() {
-    const mid = Math.floor(this.queue.length / 2);
-    for (let i = mid - 1; i >= 0; i--) {
-      this._heapify(i);
-    }
-  }
-
   /**
    * Compare parent value and children value and swap them if conditions are satisfied
    * @param index
@@ -123,13 +103,9 @@ export class PriorityQueue<T> implements IPriorityQueue<T> {
    * @param index2
    */
   private _swap(index1: number, index2: number) {
-    if (this.swapper) {
-      this.swapper(index1, index2);
-    } else {
-      const temp = this.queue[index1];
-      this.queue[index1] = this.queue[index2];
-      this.queue[index2] = temp;
-    }
+    const temp = this.queue[index1];
+    this.queue[index1] = this.queue[index2];
+    this.queue[index2] = temp;
   }
 
   /**

test/basic.spec.ts

@@ -0,0 +1,2 @@
+export const testCase1 = [2, 7, 4, 1, 8, 1];
+export const testCase2 = [4, 3, 4, 3, 2];

test/fixtures/test-case.ts

@@ -0,0 +1,124 @@
+import { PriorityQueue } from '../src';
+import { IPriorityQueue } from '../typing/priority-queue';
+import { testCase1, testCase2 } from './fixtures/test-case';
+
+describe('testing priority queue', () => {
+  let p: IPriorityQueue<number>;
+
+  describe('max priority queue', () => {
+    beforeEach(() => {
+      p = new PriorityQueue();
+    });
+
+    afterEach(() => {
+      p = null;
+    });
+
+    it('should return max heap of test case 1', () => {
+      for (let i = 0; i < testCase1.length; i++) {
+        p.push(testCase1[i]);
+      }
+      const actual = p.toArray();
+      const expected = [8, 7, 4, 1, 2, 1];
+      expect(actual).toEqual(expected);
+    });
+
+    it('should return max heap of test case 2', () => {
+      for (let i = 0; i < testCase2.length; i++) {
+        p.push(testCase2[i]);
+      }
+      const actual = p.toArray();
+      const expected = [4, 3, 4, 3, 2];
+      expect(actual).toEqual(expected);
+    });
+
+    it('should get the max value without remove', () => {
+      for (let i = 0; i < testCase2.length; i++) {
+        p.push(testCase2[i]);
+      }
+      const max = p.top();
+      expect(max).toEqual(4);
+
+      const actual = p.toArray();
+      const expected = [4, 3, 4, 3, 2];
+      expect(actual).toEqual(expected);
+    });
+
+    it('should extract the max value & rebuild max heap of test case 2', () => {
+      for (let i = 0; i < testCase2.length; i++) {
+        p.push(testCase2[i]);
+      }
+      expect(p.size()).toEqual(testCase2.length);
+      const max = p.pop();
+      expect(max).toEqual(4);
+      expect(p.size()).toEqual(testCase2.length - 1);
+
+      const actual = p.toArray();
+      const expected = [4, 3, 2, 3];
+      expect(actual).toEqual(expected);
+    });
+
+    it('should call empty & call pop and top with empty queue', () => {
+      for (let i = 0; i < testCase1.length; i++) {
+        p.push(testCase1[i]);
+      }
+
+      const expected = [8, 7, 4, 2, 1, 1];
+      let index = 0;
+
+      while (!p.empty()) {
+        const item = p.pop();
+        expect(item).toEqual(expected[index]);
+        index++;
+      }
+
+      let item = p.top();
+      expect(item).toEqual(null);
+      item = p.pop();
+      expect(item).toEqual(null);
+    });
+
+  });
+
+  describe('min priority queue', () => {
+    beforeEach(() => {
+      p = new PriorityQueue(function (a, b) {
+        return a > b;
+      });
+    });
+
+    afterEach(() => {
+      p = null;
+    });
+
+    it('should return min heap of test case 1', () => {
+      for (let i = 0; i < testCase1.length; i++) {
+        p.push(testCase1[i]);
+      }
+      const actual = p.toArray();
+      const expected = [1, 2, 1, 7, 8, 4];
+      expect(actual).toEqual(expected);
+    });
+
+    it('should return min heap of test case 2', () => {
+      for (let i = 0; i < testCase2.length; i++) {
+        p.push(testCase2[i]);
+      }
+      const actual = p.toArray();
+      const expected = [2, 3, 4, 4, 3];
+      expect(actual).toEqual(expected);
+    });
+
+    it('should extract the min value & rebuild min heap of test case 2', () => {
+      for (let i = 0; i < testCase2.length; i++) {
+        p.push(testCase2[i]);
+      }
+      const min = p.pop();
+      expect(min).toEqual(2);
+
+      const actual = p.toArray();
+      const expected = [3, 3, 4, 4];
+      expect(actual).toEqual(expected);
+    });
+  });
+});