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);
+    });
+  });
+});

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

@@ -0,0 +1,18 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('It should Find the minimum 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 minimum key', () => {
+      expect(bst.getMinimum()).toEqual(2);
+    });
+
+    it('It should expect new minimum key added to BST', () => {
+      bst.add(1);
+      expect(bst.getMinimum()).toEqual(1);
+    });
+  });
+});

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

@@ -0,0 +1,32 @@
+const BST = require('.');
+
+describe('Data Structure : Binary Search Tree', () => {
+  it('Binary Search Tree should be a Class', () => {
+    expect(typeof BST.prototype.constructor).toEqual('function');
+  });
+
+  describe('Binary Search Tree API', () => {
+    let bst = null;
+
+    beforeEach(() => {
+      bst = new BST(5);
+    });
+
+    it('Should delete() an element from Binary Search Tree', () => {
+      bst.add(4);
+      bst.add(9);
+      bst.add(2);
+      bst.delete(bst.root, 4);
+      expect(bst.traverseInorder()).toEqual([2, 5, 9]);
+      bst.delete(bst.root, 2);
+      expect(bst.traverseInorder()).toEqual([5, 9]);
+    });
+
+    it('Should return NULL if root is empty', () => {
+      const bst2 = new BST(6);
+      bst2.remove(6);
+      bst2.remove(9);
+      expect(bst2.root).toEqual(null);
+    });
+  });
+});

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

@@ -0,0 +1,17 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('It should Find the key in BST', () => {
+    const bst = new BinarySearchTree(6);
+    const keys = [4, 9, 2, 5, 8, 12];
+    keys.forEach(el => bst.add(el));
+
+    it('It should return true for 8', () => {
+      expect(bst.searchFor(8)).toEqual(true);
+    });
+
+    it('It should return false for 100', () => {
+      expect(bst.searchFor(100)).toEqual(false);
+    });
+  });
+});

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

@@ -1,5 +1,5 @@
-const BinarySearchTree = require('./index');
-const heightOfBST = require('./height-of-bst/index');
+const BinarySearchTree = require('../index');
+const heightOfBST = require('./index');
 
 describe('Binary search tree traversals', () => {
   let bst;
@@ -8,12 +8,8 @@ describe('Binary search tree traversals', () => {
     it('should create BST', () => {
       // Creates BST
       bst = new BinarySearchTree(6);
-      bst.add(4);
-      bst.add(9);
-      bst.add(2);
-      bst.add(5);
-      bst.add(8);
-      bst.add(12);
+      const keys = [4, 9, 2, 5, 8, 12];
+      keys.forEach(el => bst.add(el));
     });
   });
 
@@ -48,4 +44,14 @@ describe('Binary search tree traversals', () => {
       expect(heightOfBST(bst.root)).toEqual(2);
     });
   });
+
+  describe('When root left subtree height is greater than right', () => {
+    const bst2 = new BinarySearchTree(10);
+    const keys = [11, 20, 9, 8, 7, 6, 5, 4];
+    keys.forEach(el => bst2.add(el));
+
+    it('should return height of BST ', () => {
+      expect(heightOfBST(bst2.root)).toEqual(7);
+    });
+  });
 });

src/_DataStructures_/Trees/BinarySearchTree/bst-deletion.test.js src/_DataStructures_/Trees/BinarySearchTree/height-of-bst/height-of-bst.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable consistent-return */
 const Node = require('./Node');
 
 class BinarySearchTree {
@@ -23,7 +24,6 @@ class BinarySearchTree {
       root.rightChild = this.insert(root.rightChild, value);
       return root;
     }
-    return root;
   }
 
   preorder(root) {
@@ -80,7 +80,6 @@ class BinarySearchTree {
     if (value > root.value) {
       return this.search(root.rightChild, value);
     }
-    return false;
   }
 
   delete(root, value) {
@@ -169,7 +168,7 @@ class BinarySearchTree {
   }
 
   remove(value) {
-    return this.delete(this.root, value);
+    this.root = this.delete(this.root, value);
   }
 }
 

src/_DataStructures_/Trees/BinarySearchTree/index.js

@@ -3,22 +3,19 @@
  *
  * Given values of two values n1 and n2 in a Binary Search Tree, find the Lowest Common Ancestor (LCA). You may assume that both the values exist in the tree.
  */
- 
-function lca(node, n1, n2) {
-  if (node == null)
-    return null;
+
+function lowestCommonAncestor(node, n1, n2) {
+  if (node === null) return null;
 
   // If both n1 and n2 are smaller than root, then LCA lies in left
-  if (node.value > n1 && node.value > n2)
-    return lca(node.leftChild, n1, n2);
+  if (node.value > n1 && node.value > n2) { return lowestCommonAncestor(node.leftChild, n1, n2); }
 
   // If both n1 and n2 are greater than root, then LCA lies in right
-  if (node.value < n1 && node.value < n2)
-    return lca(node.rightChild, n1, n2);
+  if (node.value < n1 && node.value < n2) { return lowestCommonAncestor(node.rightChild, n1, n2); }
 
   return node;
 }
 
 module.exports = {
-  lca,
+  lowestCommonAncestor,
 };