sangja/test/queue.js

JavaScript data structures library

/* eslint-env node, mocha */

const { assert } = require('chai');
const { Queue } = require('../src/index');

describe('Queue', () => {
  describe('Constructor', () => {
    it('Fails without new', () => {
      assert.throws(() => Queue(), TypeError);
    });

    it('Deep equal empty instances', () => {
      assert.deepEqual(new Queue(), new Queue());
    });

    it('Constructor with iterable', () => {
      const queue = new Queue([8, 8, 3, 1]);
      assert.deepEqual([...queue], [8, 8, 3, 1]);
    });
  });

  describe('Basic Methods', () => {
    let queue = null;

    beforeEach(() => {
      queue = new Queue();
    });

    it('enqueue', () => {
      assert.equal(queue.size(), 0);
      queue.enqueue(3);
      assert.equal(queue.size(), 1);
      queue.enqueue(6);
      assert.equal(queue.size(), 2);
      queue.enqueue(9);
      assert.equal(queue.size(), 3);
    });

    it('enqueueAll', () => {
      assert.equal(queue.size(), 0);
      queue.enqueueAll([3, 6, 9]);
      assert.equal(queue.size(), 3);
      assert.deepEqual([...queue], [3, 6, 9]);
    });

    it('dequeue', () => {
      assert.equal(queue.size(), 0);
      queue.enqueue(3);
      queue.enqueue(6);
      queue.enqueue(9);
      assert.equal(queue.size(), 3);
      assert.equal(queue.dequeue(), 3);
      assert.equal(queue.size(), 2);
      assert.equal(queue.dequeue(), 6);
      assert.equal(queue.size(), 1);
      assert.equal(queue.dequeue(), 9);
      assert.equal(queue.size(), 0);
    });

    it('dequeue when size===0', () => {
      assert.equal(queue.dequeue(), undefined);
      assert.equal(queue.dequeue(), undefined);
      assert.equal(queue.size(), 0);
    });

    it('peek', () => {
      queue.enqueue(3);
      queue.enqueue(6);
      queue.enqueue(9);
      assert.equal(queue.peek(), 3);
      queue.dequeue();
      assert.equal(queue.peek(), 6);
      queue.dequeue();
      assert.equal(queue.peek(), 9);
      queue.dequeue();
      assert.equal(queue.dequeue(), undefined);
    });

    it('isEmpty', () => {
      assert.isTrue(queue.isEmpty());
      queue.enqueue(3);
      assert.isFalse(queue.isEmpty());
      assert.equal(queue.dequeue(), 3);
      assert.isTrue(queue.isEmpty());
      assert.equal(queue.dequeue(), undefined);
      assert.isTrue(queue.isEmpty());
    });

    it('clear', () => {
      assert.equal(queue.size(), 0);
      queue.enqueueAll([3, 6, 9]);
      assert.equal(queue.size(), 3);
      queue.clear();
      assert.equal(queue.size(), 0);
    });

    it('reversed', () => {
      queue.enqueueAll([3, 6, 9]);
      assert.deepEqual([...queue], [3, 6, 9]);
      assert.deepEqual([...queue.reversed()], [9, 6, 3]);
    });
  });

  describe('Iterator', () => {
    let queue = null;

    beforeEach(() => {
      queue = new Queue();
    });

    it('Iterate without value', () => {
      assert.deepEqual([...queue], []);
    });

    it('Iterate one value', () => {
      queue.enqueue(3);
      assert.deepEqual([...queue], [3]);
    });

    it('Iterate some values', () => {
      queue.enqueue(3);
      queue.enqueue(6);
      queue.enqueue(9);
      assert.deepEqual([...queue], [3, 6, 9]);
    });
  });

  describe('Functional tools', () => {
    let queue = null;

    it('forEach', () => {
      queue = new Queue();
      let acc = 0;
      const accmulate = (x) => { acc += x; };

      assert.equal(acc, 0);
      queue.forEach(accmulate);
      assert.equal(acc, 0);

      queue.enqueueAll([11, 22, 33]);
      queue.forEach(accmulate);
      assert.equal(acc, 66);
    });

    it('map', () => {
      queue = new Queue();
      assert.deepEqual([...queue.map(x => x + 3)], []);

      queue.enqueueAll([11, 22, 33]);
      assert.deepEqual([...queue.map(x => x + 3)], [14, 25, 36]);
    });

    it('flatMap', () => {
      queue = new Queue();
      assert.deepEqual([...queue.flatMap(x => [x, x + 3])], []);

      queue.enqueueAll([11, 22, 33]);
      assert.deepEqual([...queue.flatMap(x => [x, x + 3])], [11, 14, 22, 25, 33, 36]);
    });

    it('filter', () => {
      queue = new Queue();
      assert.deepEqual([...queue.filter(x => x % 2)], []);

      queue.enqueueAll([1, 2, 3, 4, 5]);
      assert.deepEqual([...queue.filter(x => x % 2)], [1, 3, 5]);
      assert.deepEqual([...queue], [1, 2, 3, 4, 5]);
    });
  });

  describe('Checking tools', () => {
    it('some', () => {
      assert.equal(new Queue().some(x => x > 5), false);
      assert.equal(new Queue([1, 2, 3]).some(x => x > 5), false);
      assert.equal(new Queue([4, 5, 6]).some(x => x > 5), true);
      assert.equal(new Queue([7, 8, 9]).some(x => x > 5), true);
    });

    it('every', () => {
      assert.equal(new Queue().every(x => x > 5), true);
      assert.equal(new Queue([1, 2, 3]).every(x => x > 5), false);
      assert.equal(new Queue([4, 5, 6]).every(x => x > 5), false);
      assert.equal(new Queue([7, 8, 9]).every(x => x > 5), true);
    });

    it('includes', () => {
      assert.equal(new Queue().includes(5), false);
      assert.equal(new Queue([1, 2, 3]).includes(5), false);
      assert.equal(new Queue([4, 5, 6]).includes(5), true);
      assert.equal(new Queue([5]).includes(5), true);
    });
  });
});