@Test
  public void testDFS_RandomBST() {
    int MAX_ITER = 100;
    int MAX_SIZE = 10;

    for (int iter = 0; iter < MAX_ITER; iter++) {
      List<Integer> lstVals = new ArrayList<Integer>();
      BinarySearchTree<Integer> bst = generateRandomIntTree(MAX_SIZE, lstVals, true);
      Comparator<Integer> comp = bst.getComp();
      String msg =
          "Searching for values "
              + lstVals
              + " in tree with values inserted in the same order : "
              + lstVals;
      for (int val : lstVals) {
        BinaryTreeNode<Integer> node = TreeUtil.dfs(bst.getRoot(), val, comp);
        assertNotNull(msg, node);
        assertEquals(msg, val, node.getVal().intValue());
      }

      // Testing for values that do not exist
      for (int i = 0; i < 100; i++) {
        if (!lstVals.contains(i)) {
          assertNull(msg, TreeUtil.dfs(bst.getRoot(), i, comp));
        }
      }
    }
  }
 @Test
 public void testLevelOrderTraversal_EmptyTree() {
   BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>();
   List<List<Integer>> lst = TreeUtil.levelOrderTraversal(bst.getRoot());
   assertNotNull("Expecting an empty list in case root node is null", lst);
   assertTrue("Expecting an empty list in case root node is null", lst.isEmpty());
 }
 @Test
 public void reverseOrderTraversal_EmptyTree() {
   BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>();
   assertTrue(
       "Expected an empty list for an empty tree",
       TreeUtil.reverseLevelOrderTraversal(bst.getRoot()).isEmpty());
 }
 @Test
 public void testDFS_TreeWithSingleNode() {
   BinarySearchTree<Integer> bst = getTreeWithRootNode();
   Comparator<Integer> comp = getIntComparator();
   String msg =
       "Searching for values 0 to 9 in tree with values inserted in the same order : [ 1 ]";
   for (int i = 0; i < 10; i++) {
     if (i == 1) {
       BinaryTreeNode<Integer> node = TreeUtil.dfs(bst.getRoot(), i, comp);
       assertNotNull(msg, node);
       assertEquals(msg, 1, node.getVal().intValue());
     } else {
       assertNull(TreeUtil.bfs(bst.getRoot(), i, comp));
     }
   }
 }
  private static BinarySearchTree<Integer> getSimpleBST() {

    BinarySearchTree<Integer> bst =
        new BinarySearchTree<Integer>(new BinaryTreeNode<Integer>(2), getIntComparator());
    bst.getRoot().setLeft(new BinaryTreeNode<Integer>(1));
    bst.getRoot().setRight(new BinaryTreeNode<Integer>(3));
    return bst;
  }
 @Test
 public void testLevelOrderTraversal_SingleNode() {
   BinarySearchTree<Integer> bst = getTreeWithRootNode();
   List<List<Integer>> lst = TreeUtil.levelOrderTraversal(bst.getRoot());
   String msg = "Expecting [ [1] ]";
   assertNotNull(msg, lst);
   assertEquals(msg, 1, lst.size());
   assertEquals(msg, 1, lst.get(0).size());
   assertEquals(msg, 1, lst.get(0).get(0).intValue());
 }
 @Test
 public void reverseOrderTraversal_SingleNode() {
   BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>();
   bst.setComp(getIntComparator());
   bst.insert(1);
   List<Integer> lst = TreeUtil.reverseLevelOrderTraversal(bst.getRoot());
   assertTrue("Expected a non empty list for tree with single node", !lst.isEmpty());
   assertTrue("Expecting size of the list to be 1", lst.size() == 1);
   assertEquals(1, (int) lst.get(0));
 }
 @Test
 public void testLevelOrderTraversal_SimpleBST() {
   BinarySearchTree<Integer> bst = getSimpleBST();
   List<List<Integer>> lst = TreeUtil.levelOrderTraversal(bst.getRoot());
   String msg = "Expecting [ [2], [ 1, 3] ]";
   List<List<Integer>> expectedValLst = new ArrayList<List<Integer>>();
   expectedValLst.add(new ArrayList<Integer>());
   expectedValLst.add(new ArrayList<Integer>());
   expectedValLst.get(0).add(2);
   expectedValLst.get(1).add(1);
   expectedValLst.get(1).add(3);
   assertNotNull(msg, lst);
   assertEquals(msg, expectedValLst.size(), lst.size());
   for (int index = 0; index < expectedValLst.size(); index++) {
     List<Integer> eLst = expectedValLst.get(index);
     List<Integer> aLst = lst.get(index);
     assertEquals(msg, eLst.size(), aLst.size());
     for (int index1 = 0; index1 < eLst.size(); index1++) {
       assertEquals(msg, eLst.get(index1), aLst.get(index1));
     }
   }
 }
 @Test
 public void reverseOrderTraversal_SimpleTestCase() {
   BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>();
   bst.setComp(getIntComparator());
   bst.insert(100);
   bst.insert(50);
   bst.insert(150);
   bst.insert(30);
   bst.insert(70);
   bst.insert(60);
   bst.insert(120);
   bst.insert(130);
   bst.insert(170);
   bst.insert(160);
   List<Integer> lst = TreeUtil.reverseLevelOrderTraversal(bst.getRoot());
   assertTrue("Expected a non empty list for tree with single node", !lst.isEmpty());
   int[] expectedVals = new int[] {60, 130, 160, 30, 70, 120, 170, 50, 150, 100};
   assertTrue("Expecting size of the list to be 3", lst.size() == expectedVals.length);
   for (int index = 0; index < expectedVals.length; index++) {
     assertEquals(expectedVals[index], (int) lst.get(index));
   }
 }
  @Test
  public void testLevelOrderTraversal_HandCraftedTree() {
    BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>();
    bst.setComp(getIntComparator());
    List<List<Integer>> expectValList = new ArrayList<List<Integer>>();
    bst.insert(100);
    int level = 0;
    expectValList.add(new ArrayList<Integer>());
    expectValList.get(level).add(100);

    level++;
    expectValList.add(new ArrayList<Integer>());
    bst.insert(50);
    expectValList.get(level).add(50);
    bst.insert(150);
    expectValList.get(level).add(150);

    level++;
    expectValList.add(new ArrayList<Integer>());
    bst.insert(30);
    expectValList.get(level).add(30);
    bst.insert(130);
    expectValList.get(level).add(130);
    bst.insert(180);
    expectValList.get(level).add(180);

    List<List<Integer>> lst = TreeUtil.levelOrderTraversal(bst.getRoot());
    String msg = "Input Tree : [ 100, 50, 150, 30, #, 130, 180 ]";
    assertNotNull(msg, lst);
    assertEquals(msg, expectValList.size(), lst.size());
    for (int index = 0; index < expectValList.size(); index++) {
      List<Integer> eLst = expectValList.get(index);
      List<Integer> aLst = lst.get(index);
      assertEquals(msg, eLst.size(), aLst.size());
      for (int index1 = 0; index1 < eLst.size(); index1++) {
        assertEquals(msg, eLst.get(index1), aLst.get(index1));
      }
    }
  }