refactor: move all tests to a single file

Author: ashokdey

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

@@ -0,0 +1,170 @@
+const BinarySearchTree = require('./index');
+
+describe('Data Structure : Binary Search Tree', () => {
+  let bst;
+  let rootsLeftChild;
+  let rootsRightChild;
+  let rootsLeftChildsLeftChild;
+  let rootsLeftChildsRightChild;
+  let rootsRightChildsLeftChild;
+  let rootsRightChildsRightChild;
+
+  it('Binary Search Tree should be a Class', () => {
+    expect(typeof BinarySearchTree.prototype.constructor).toEqual('function');
+  });
+
+  describe('Creation of BST', () => {
+    it('Should create a BST with root 100', () => {
+      bst = new BinarySearchTree(100);
+      expect(bst.root.value).toEqual(100);
+    });
+
+    it('Should add element 20 to the left of root node', () => {
+      bst.add(20);
+      rootsLeftChild = bst.root.leftChild;
+      expect(rootsLeftChild.value).toEqual(20);
+    });
+
+    it('Should add element 500 to the right of root node', () => {
+      bst.add(500);
+      rootsRightChild = bst.root.rightChild;
+      expect(rootsRightChild.value).toEqual(500);
+    });
+
+    it('Should add element 10 to the left of root"s left child', () => {
+      bst.add(10);
+      rootsLeftChildsLeftChild = bst.root.leftChild.leftChild;
+      expect(rootsLeftChildsLeftChild.value).toEqual(10);
+    });
+
+    it('Should add element 30 to the right of root"s left child', () => {
+      bst.add(30);
+      rootsLeftChildsRightChild = bst.root.leftChild.rightChild;
+      expect(rootsLeftChildsRightChild.value).toEqual(30);
+    });
+
+    it("Should add element 400 to the left of root's right child", () => {
+      bst.add(400);
+      rootsRightChildsLeftChild = bst.root.rightChild.leftChild;
+      expect(rootsRightChildsLeftChild.value).toEqual(400);
+    });
+
+    it("Should add element 600 to the right of root's right child", () => {
+      bst.add(600);
+      rootsRightChildsRightChild = bst.root.rightChild.rightChild;
+      expect(rootsRightChildsRightChild.value).toEqual(600);
+    });
+  });
+
+  describe('Check insertion was as expected', () => {
+    it('Inorder traversal of the created bst should be [ 10, 20, 30, 100, 400, 500, 600 ]', () => {
+      expect(bst.inorder()).toEqual([10, 20, 30, 100, 400, 500, 600]);
+    });
+
+    it('Preorder traversal of the created bst should be [ 100, 20, 10, 30, 500, 400, 600 ]', () => {
+      expect(bst.preorder()).toEqual([100, 20, 10, 30, 500, 400, 600]);
+    });
+
+    it('Postorder traversal of the created bst should be [ 10, 30, 20, 400, 600, 500, 100 ]', () => {
+      expect(bst.postorder()).toEqual([10, 30, 20, 400, 600, 500, 100]);
+    });
+  });
+
+  describe('Check if BST `Is Empty`', () => {
+    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);
+    });
+  });
+
+  describe('Find maximum value in BST', () => {
+    bst = new BinarySearchTree(6);
+    [4, 9, 2, 5, 8, 12].forEach(el => bst.add(el));
+
+    it('Should expect maximum key', () => {
+      expect(bst.getMaximum()).toEqual(12);
+    });
+
+    it('Should expect new maximum key added in BST', () => {
+      bst.add(20);
+      expect(bst.getMaximum()).toEqual(20);
+    });
+  });
+
+  describe('Find the minimum value in BST', () => {
+    bst = new BinarySearchTree(6);
+    [4, 9, 2, 5, 8, 12].forEach(el => bst.add(el));
+
+    it('Should expect minimum key', () => {
+      expect(bst.getMinimum()).toEqual(2);
+    });
+
+    it('Should expect new minimum key added to BST', () => {
+      bst.add(1);
+      expect(bst.getMinimum()).toEqual(1);
+    });
+  });
+
+  describe('Remove Node in BST', () => {
+    bst = null;
+
+    beforeEach(() => {
+      bst = new BinarySearchTree(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.inorder()).toEqual([2, 5, 9]);
+      bst.delete(bst.root, 2);
+      expect(bst.inorder()).toEqual([5, 9]);
+    });
+
+    it('Should return NULL if root is empty', () => {
+      const bst2 = new BinarySearchTree(6);
+      bst2.remove(6);
+      bst2.remove(9);
+      expect(bst2.root).toEqual(null);
+    });
+  });
+
+  describe('Search value in BST', () => {
+    bst = new BinarySearchTree(6);
+    [4, 9, 2, 5, 8, 12].forEach(el => bst.add(el));
+
+    it('Should return `true` for 8', () => {
+      expect(bst.searchFor(8)).toEqual(true);
+    });
+
+    it('Should return `false` for 100', () => {
+      expect(bst.searchFor(100)).toEqual(false);
+    });
+  });
+
+  describe('Traversals in BST', () => {
+    it('Should return the `Preorder Traversal` for given BST', () => {
+      const preOrderTraversal = bst.preorder();
+      expect(preOrderTraversal).toEqual([6, 4, 2, 5, 9, 8, 12]);
+    });
+
+    it('Should return the `Inorder Traversal` for given BST', () => {
+      const inOrderTraversal = bst.inorder();
+      expect(inOrderTraversal).toEqual([2, 4, 5, 6, 8, 9, 12]);
+    });
+
+    it('Should return the `Postorder Traversal` for given BST', () => {
+      const postOrderTraversal = bst.postorder();
+      expect(postOrderTraversal).toEqual([2, 5, 4, 8, 12, 9, 6]);
+    });
+  });
+});

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

@@ -15,15 +15,15 @@ describe('Binary search tree traversals', () => {
 
   describe('Check bst was created as expected', () => {
     it('Inorder traversal of the created bst should be [ 2, 4, 5, 6, 8, 9, 12 ]', () => {
-      expect(bst.traverseInorder()).toEqual([2, 4, 5, 6, 8, 9, 12]);
+      expect(bst.inorder()).toEqual([2, 4, 5, 6, 8, 9, 12]);
     });
 
     it('Preorder traversal of the created bst should be [ 6, 4, 2, 5, 9, 8, 12 ]', () => {
-      expect(bst.traversePreorder()).toEqual([6, 4, 2, 5, 9, 8, 12]);
+      expect(bst.preorder()).toEqual([6, 4, 2, 5, 9, 8, 12]);
     });
 
     it('Postorder traversal of the created bst should be  [ 2, 5, 4, 8, 12, 9, 6 ]', () => {
-      expect(bst.traversePostorder()).toEqual([2, 5, 4, 8, 12, 9, 6]);
+      expect(bst.postorder()).toEqual([2, 5, 4, 8, 12, 9, 6]);
     });
   });
 

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

@@ -27,7 +27,7 @@ function findHeightOfBST(root) {
 // myBST.add(10);
 
 // // console.log(myBST.root);
-// console.log(myBST.traversePreorder());
+// console.log(myBST.preorder());
 // console.log(findHeightOfBST(myBST.root));
 
 module.exports = findHeightOfBST;

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

@@ -23,11 +23,11 @@ class BinarySearchTree {
     return this.BSTUtils.preorder(this.root);
   }
 
-  traversePostorder() {
+  postorder() {
     return this.BSTUtils.postorder(this.root);
   }
 
-  traverseInorder() {
+  inorder() {
     return this.BSTUtils.inorder(this.root);
   }
 
@@ -61,13 +61,13 @@ class BinarySearchTree {
 
 // console.log(bst.root);
 
-// const preorder = bst.traversePreorder();
+// const preorder = bst.preorder();
 // console.log('Preorder Traversal - ', preorder);
 
-// const inorder = bst.traverseInorder();
+// const inorder = bst.inorder();
 // console.log('Inorder Traversal - ', inorder);
 
-// const postorder = bst.traversePostorder();
+// const postorder = bst.postorder();
 // console.log('Postorder Traversal - ', postorder);
 
 // const search = 18;
@@ -80,7 +80,7 @@ class BinarySearchTree {
 // console.log('Maximum value =>', maxNode);
 
 // bst.remove(4);
-// console.log(bst.traversePreorder());
+// console.log(bst.preorder());
 
 // console.log(bst.root);
 

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

@@ -21,26 +21,26 @@ class BinaryTree {
     return root;
   }
 
-  traversePreorder(root) {
+  preorder(root) {
     let arr = [];
 
     if (root === null) return arr;
     // push node to arr
     arr.push(root.value);
 
     // push left node
-    const left = this.traversePreorder(root.leftChild);
+    const left = this.preorder(root.leftChild);
     arr = [...arr, ...left];
 
     // push right node
-    const right = this.traversePreorder(root.rightChild);
+    const right = this.preorder(root.rightChild);
     arr = [...arr, ...right];
 
     return arr;
   }
 
   preOrder() {
-    return this.traversePreorder(this.root);
+    return this.preorder(this.root);
   }
 }
 

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

@@ -23,7 +23,7 @@ const myBST = new BST(51);
 
 [10, 34, 32, 12, 90, 54, 61, 2, 71, 9].forEach(e => myBST.add(e));
 
-const preOrderElements = myBST.traversePreorder();
+const preOrderElements = myBST.preorder();
 const levelOrderElements = traverseBFS(myBST.root);
 
 // eslint-disable-next-line no-console