Merge pull request knaxus#142 from knaxus/codeCoverage

Increase code coverage

Author: ashokdey

src/_DataStructures_/DoublyLinkedList/Node.js

@@ -0,0 +1,8 @@
+class Node {
+  constructor(data, previous, next) {
+    this.data = data;
+    this.previous = previous;
+    this.next = next;
+  }
+}
+module.exports = Node;

src/_DataStructures_/DoublyLinkedList/doublyLinkedList.test.js

@@ -0,0 +1,44 @@
+const DLL = require('.');
+
+describe('Doubly Linked List', () => {
+  it('Doubly linked list should be class', () => {
+    expect(typeof DLL.prototype.constructor).toEqual('function');
+  });
+
+  const doublyLinkedList = new DLL();
+
+  it('It should create a DLL', () => {
+    expect(doublyLinkedList.head.next).toEqual(doublyLinkedList.tail);
+    expect(doublyLinkedList.tail.previous).toEqual(doublyLinkedList.head);
+    expect(doublyLinkedList.length()).toEqual(0);
+  });
+
+  it('It should add at beginning (addAtBeginning)', () => {
+    doublyLinkedList.addAtBeginning(1);
+    doublyLinkedList.addAtBeginning(2);
+    doublyLinkedList.addAtBeginning(3);
+    expect(doublyLinkedList.traverse()).toEqual([3, 2, 1]);
+  });
+
+  it('It should add at end (addAtEnd)', () => {
+    doublyLinkedList.addAtEnd(1);
+    doublyLinkedList.addAtEnd(2);
+    doublyLinkedList.addAtEnd(3);
+    expect(doublyLinkedList.traverse()).toEqual([3, 2, 1, 1, 2, 3]);
+  });
+
+  it('It should remove at beginning (removeAtBeginning)', () => {
+    doublyLinkedList.removeAtBeginning();
+    doublyLinkedList.removeAtBeginning();
+    doublyLinkedList.removeAtBeginning();
+    expect(doublyLinkedList.traverse()).toEqual([1, 2, 3]);
+  });
+
+  it('It should remove at end (removeAtEnd)', () => {
+    doublyLinkedList.removeAtEnd();
+    doublyLinkedList.removeAtEnd();
+    doublyLinkedList.removeAtEnd();
+
+    expect(doublyLinkedList.traverse()).toEqual([]);
+  });
+});

src/_DataStructures_/DoublyLinkedList/index.js

@@ -1,11 +1,5 @@
 /* eslint-disable class-methods-use-this */
-class Node {
-  constructor(data, previous, next) {
-    this.data = data;
-    this.previous = previous;
-    this.next = next;
-  }
-}
+const Node = require('./Node');
 
 class DoublyLinkedList {
   constructor() {

src/_DataStructures_/LinkedList/LinkedList.test.js

@@ -68,6 +68,7 @@ describe('Data Structures: Linked Lists', () => {
         list.addAtEnd(10);
 
         expect(list.length()).toEqual(4);
+        expect(list.traverseList()).toEqual([15, 23, 33, 10]);
       });
     });
 

src/_DataStructures_/Queue/Queue.test.js

@@ -1,7 +1,7 @@
 const Queue = require('.');
 
 describe('Data Structure : Queue', () => {
-  it('Should be class', () => {
+  it('Queue should be class', () => {
     expect(typeof Queue.prototype.constructor).toEqual('function');
   });
 
@@ -53,6 +53,30 @@ describe('Data Structure : Queue', () => {
       expect(queue.dequeue()).toEqual(1);
       expect(queue.dequeue()).toEqual(4);
       expect(queue.dequeue()).toEqual(3);
+      expect(queue.dequeue()).toEqual(null);
+    });
+
+    it('Shoud return size of Queue', () => {
+      const queue2 = new Queue();
+      queue2.enqueue(2);
+      queue2.enqueue(1);
+      queue2.enqueue(4);
+      queue2.enqueue(3);
+      expect(queue2.length()).toEqual(4);
+    });
+
+    it('Should Destroy Queue', () => {
+      queue.destroy();
+      expect(queue.length()).toEqual(0);
+    });
+
+    it('Override and throw error for other LL methods', () => {
+      expect(() => { queue.addAtBeginning(); }).toThrowError('Not Allowed');
+      expect(() => { queue.addAt(); }).toThrowError('Not Allowed');
+      expect(() => { queue.removeFromEnd(); }).toThrowError('Not Allowed');
+      expect(() => { queue.getLast(); }).toThrowError('Not Allowed');
+      expect(() => { queue.getAt(); }).toThrowError('Not Allowed');
+      expect(() => { queue.removeAt(); }).toThrowError('Not Allowed');
     });
   });
 });

src/_DataStructures_/Stack/postfix-expression-evaluation/index.js

@@ -43,7 +43,7 @@ function evaluatePostfixExpression(expression) {
           s.push(val2 / val1);
           break;
         default:
-          break;
+          throw new Error('Operation is not valid');
       }
     }
   }

src/_DataStructures_/Stack/postfix-expression-evaluation/postfix-expression-evaluation.test.js

@@ -58,5 +58,8 @@ describe('Postfix expression evaluation', () => {
     test.each(invalidExpressions)('running for %p', (expression) => {
       expect(() => evaluatePostfixExpression(expression)).toThrow(ERROR_STRING);
     });
+
+    expect(() => evaluatePostfixExpression('1&2')).toThrow('Operation is not valid');
+
   });
 });

src/_DataStructures_/Trees/BinarySearchTree/BinarySearchTree.test.js

@@ -0,0 +1,18 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('Is Empty', () => {
+    const bst = new BinarySearchTree(6);
+    const keys = [4, 9, 2, 5, 8, 12];
+    keys.forEach(el => bst.add(el));
+    it('should return False when BST is not empty', () => {
+      expect(bst.isEmpty()).toEqual(false);
+    });
+
+    it('should return True when BST is empty', () => {
+      keys.push(6);
+      keys.forEach(el => bst.remove(el));
+      expect(bst.isEmpty()).toEqual(true);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-isEmpty.test.js

@@ -0,0 +1,18 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('Find maximum value in BST', () => {
+    const bst = new BinarySearchTree(6);
+    const keys = [4, 9, 2, 5, 8, 12];
+    keys.forEach(el => bst.add(el));
+
+    it('It should expect maximum key', () => {
+      expect(bst.getMaximum()).toEqual(12);
+    });
+
+    it('It should expect new maximum key added in BST', () => {
+      bst.add(20);
+      expect(bst.getMaximum()).toEqual(20);
+    });
+  });
+});