3.1 multistack tests and implementation

Author: amejiarosario

src/stacks-and-queues/multi-stack.js

@@ -12,34 +12,39 @@ class MultiStack {
   }
 
   push(stackIndex, data) {
-    const stack = this.stacks[stackIndex];
+    const stack = this.getStack(stackIndex);
 
     if(stack.current < stack.end) {
-      this.array[stack.current] = data;
-      stack.current++;
+      this.array[stack.current++] = data;
     } else {
-      throw new Error(`Stack #${stackIndex} overflow at ${stack.current}`);
+      throw new Error('Stack overflow');
     }
   }
 
   pop(stackIndex) {
-    const stack = this.stacks[stackIndex];
-
-    if(this.isEmpty(stackIndex)) {
-      return null;
-    } else {
+    const stack = this.getStack(stackIndex);
+    if(stack.current !== stack.start) {
       return this.array[--stack.current];
     }
   }
 
   peek(stackIndex) {
-    const stack = this.stacks[stackIndex];
-
+    const stack = this.getStack(stackIndex);
+    return this.array[stack.current - 1];
   }
 
   isEmpty(stackIndex) {
-    const stack = this.stacks[stackIndex];
-    return stack.current < stack.start;
+    const stack = this.getStack(stackIndex);
+    return stack.current === stack.start;
   }
 
-}
+  getStack(stackIndex) {
+    if(stackIndex < 0 || stackIndex > 2) {
+      throw new Error(`Stack ${stackIndex} does not exist`);
+    }
+    return this.stacks[stackIndex];
+  }
+
+}
+
+module.exports = MultiStack;

src/stacks-and-queues/multi-stack.spec.js

@@ -5,21 +5,114 @@ describe('Stacks: Multistack', function () {
   var multiStack;
 
   beforeEach(function () {
-    multiStack = new MultiStack();
+    multiStack = new MultiStack(6);
   });
 
-  it('should add 300 hundred element to each stack and retrive the data', function () {
-    for(let stackIndex = 0; stackIndex < 3; stackIndex++) {
-      for(let data = 0; data < 300; data++) {
-        multiStack.push(stackIndex, data);
-      }
-    }
-
-    for(let data = 299; data > -1; data--) {
-      for(let stackIndex = 0; stackIndex < 3; stackIndex++) {
-        var actual = multiStack.pop(stackIndex);
-        expect(actual).to.equal(data, `Expected stack #${stackIndex} data to be ${data} but was ${actual}`);
-      }
-    }
+  describe('.push', function () {
+    it('should add an element on stack 0', function () {
+      multiStack.push(0, 'a');
+      expect(multiStack.array).to.eql(['a']);
+    });
+
+    it('should add an element on stack 0, 1, 2', function () {
+      multiStack.push(0, 'a');
+      multiStack.push(1, 'b');
+      multiStack.push(2, 'c');
+
+      expect(multiStack.array[0]).to.equal('a');
+      expect(multiStack.array[1]).to.be.an('undefined');
+      expect(multiStack.array[2]).to.equal('b');
+      expect(multiStack.array[3]).to.be.an('undefined');
+      expect(multiStack.array[4]).to.equal('c');
+    });
+
+    it('should overflow when adding too much elements', function () {
+      multiStack.push(0, 'a');
+      multiStack.push(0, 'b');
+      function overflow() { multiStack.push(0, 'c'); }
+      expect(overflow).to.throw(Error);
+      expect(overflow).to.throw(/overflow/gi);
+    });
+  });
+
+  describe('.isEmpty', function () {
+    it('should start empty', function () {
+      expect(multiStack.isEmpty(1)).to.equal(true);
+    });
+
+    it('should not be empty after adding an element', function () {
+      multiStack.push(1, 'b');
+      expect(multiStack.isEmpty(1)).to.equal(false);
+    });
+  });
+
+  describe('.getStack', function () {
+    it('should throw error if there is no index', function () {
+      expect(multiStack.getStack).to.throw(Error);
+    });
+
+    it('should throw error if index is 3', function () {
+      function actual() { multiStack.getStack(3) }
+      expect(actual).to.throw(Error);
+    });
+
+    it('should NOT throw error if index is 2', function () {
+      function actual() { multiStack.getStack(2) }
+      expect(actual).not.to.throw(Error);
+    });
+
+    it('should NOT throw error if index is 0', function () {
+      function actual() { multiStack.getStack(0) }
+      expect(actual).not.to.throw(Error);
+    });
+
+    it('should throw error if index is -1', function () {
+      function actual() { multiStack.getStack(-1) }
+      expect(actual).to.throw(Error);
+    });
+  });
+
+  describe('.pop', function () {
+    it('should pop last element', function () {
+      multiStack.push(0, 'a');
+      expect(multiStack.pop(0)).to.equal('a');
+    });
+
+    it('should return elements on FIFO', function () {
+      multiStack.push(0, 'a');
+      multiStack.push(0, 'b');
+      expect(multiStack.pop(0)).to.equal('b');
+      expect(multiStack.pop(0)).to.equal('a');
+    });
+
+    it('should not have a negative index on empty', function () {
+      expect(multiStack.pop(0)).to.equal(undefined);
+      expect(multiStack.getStack(0).current).to.equal(0);
+    });
+
+    it('should return undefined when pop more than number of elements', function () {
+      multiStack.push(0, 'a');
+      expect(multiStack.pop(0)).to.equal('a');
+      expect(multiStack.pop(0)).to.equal(undefined);
+      expect(multiStack.getStack(0).current).to.equal(0);
+    });
+
+    it('should pop from multiple stacks', function () {
+      multiStack.push(0, 'a');
+      multiStack.push(0, 'b');
+      multiStack.push(1, 'a');
+      multiStack.push(1, 'b');
+      expect(multiStack.pop(0)).to.equal('b');
+      expect(multiStack.pop(0)).to.equal('a');
+      expect(multiStack.pop(1)).to.equal('b');
+      expect(multiStack.pop(1)).to.equal('a');
+    });
+  });
+
+  describe('.peek', function () {
+    it('should return last element', function () {
+      multiStack.push(0, 'a');
+      expect(multiStack.peek(0)).to.equal('a');
+    });
   });
 });