sangja/test/stack.js

JavaScript data structures library

/* eslint-env node, mocha */

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

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

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

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

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

    beforeEach(() => {
      stack = new Stack();
    });

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

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

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

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

    it('top', () => {
      stack.push(3);
      stack.push(6);
      stack.push(9);
      assert.equal(stack.top(), 9);
      stack.pop();
      assert.equal(stack.top(), 6);
      stack.pop();
      assert.equal(stack.top(), 3);
      stack.pop();
      assert.equal(stack.pop(), undefined);
    });

    it('clear', () => {
      assert.equal(stack.size(), 0);
      stack.push(3);
      stack.push(6);
      stack.push(9);
      assert.equal(stack.size(), 3);
      stack.clear();
      assert.equal(stack.size(), 0);
    });

    it('isEmpty', () => {
      assert.isTrue(stack.isEmpty());
      stack.push(3);
      assert.isFalse(stack.isEmpty());
      assert.equal(stack.pop(), 3);
      assert.isTrue(stack.isEmpty());
      assert.equal(stack.pop(), undefined);
      assert.isTrue(stack.isEmpty());
    });

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

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

    beforeEach(() => {
      stack = new Stack();
    });

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

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

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

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

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

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

      stack.push(11);
      stack.push(22);
      stack.push(33);
      stack.forEach(accmulate);
      assert.equal(acc, 66);
    });

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

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

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

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

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

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

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

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

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