Thread: JUnit Test Confusion.

So I've got a Binary Search Tree class called BST that I use to properly organize my Binary Tree. I've also got a BstApp main class for testing it. The program works fine, however my assignment asks us to make a JUnit test, to test three of the methods in BST, these are (preOrder, inOrder, postOrder) In order to do this I decided I would make a queue that contained the values desired for each method, then use an assertEqualls to compare that value with a actual test value. However, I've gotten myself confused on how the best way to accomplish this would be. I created a BST object in the JUnit test, and tried comparing one of the three methods against the queues elements use an enhanced for loop and it wouldn't let me call any of the order methods in BST except for levelOrder.

BST.java

/*************************************************************************
 *  
 * Based on BST.java from Algorithms 4 by Sedgewick
 *
 *************************************************************************/
 
import java.util.NoSuchElementException;
 
public class BST<Key extends Comparable<Key>, Value>
{
	private Node root; // root of BST
 
	private class Node
	{
		private Key key; // sorted by key
		private Value val; // associated data
		private Node left, right; // left and right subtrees
		private int N; // number of nodes in subtree
 
		public Node(Key key, Value val, int N)
		{
			this.key = key;
			this.val = val;
			this.N = N;
		}
	}
 
	// is the symbol table empty?
	public boolean isEmpty()
	{
		return size() == 0;
	}
 
	// return number of key-value pairs in BST
	public int size()
	{
		return size(root);
	}
 
	// return number of key-value pairs in BST rooted at x
	private int size(Node x)
	{
		if (x == null)
			return 0;
		else
			return x.N;
	}
 
	/***********************************************************************
	 * Search BST for given key, and return associated value if found, return
	 * null if not found
	 ***********************************************************************/
	// does there exist a key-value pair with given key?
	public boolean contains(Key key)
	{
		return get(key) != null;
	}
 
	// return value associated with the given key, or null if no such key exists
	public Value get(Key key)
	{
		return get(root, key);
	}
 
	private Value get(Node x, Key key)
	{
		if (x == null)
			return null;
		int cmp = key.compareTo(x.key);
		if (cmp < 0)
			return get(x.left, key);
		else if (cmp > 0)
			return get(x.right, key);
		else
			return x.val;
	}
 
	/***********************************************************************
	 * Insert key-value pair into BST If key already exists, update with new
	 * value
	 ***********************************************************************/
	public void put(Key key, Value val)
	{
		if (val == null)
		{
			delete(key);
			return;
		}
		root = put(root, key, val);
		assert check();
	}
 
	private Node put(Node x, Key key, Value val)
	{
		if (x == null)
			return new Node(key, val, 1);
		int cmp = key.compareTo(x.key);
		if (cmp < 0)
			x.left = put(x.left, key, val);
		else if (cmp > 0)
			x.right = put(x.right, key, val);
		else
			x.val = val;
		x.N = 1 + size(x.left) + size(x.right);
		return x;
	}
 
	/***********************************************************************
	 * Delete
	 ***********************************************************************/
 
	public void deleteMin()
	{
		if (isEmpty())
			throw new NoSuchElementException("Symbol table underflow");
		root = deleteMin(root);
		assert check();
	}
 
	private Node deleteMin(Node x)
	{
		if (x.left == null)
			return x.right;
		x.left = deleteMin(x.left);
		x.N = size(x.left) + size(x.right) + 1;
		return x;
	}
 
	public void deleteMax()
	{
		if (isEmpty())
			throw new NoSuchElementException("Symbol table underflow");
		root = deleteMax(root);
		assert check();
	}
 
	private Node deleteMax(Node x)
	{
		if (x.right == null)
			return x.left;
		x.right = deleteMax(x.right);
		x.N = size(x.left) + size(x.right) + 1;
		return x;
	}
 
	public void delete(Key key)
	{
		root = delete(root, key);
		assert check();
	}
 
	private Node delete(Node x, Key key)
	{
		if (x == null)
			return null;
		int cmp = key.compareTo(x.key);
		if (cmp < 0)
			x.left = delete(x.left, key);
		else if (cmp > 0)
			x.right = delete(x.right, key);
		else
		{
			if (x.right == null)
				return x.left;
			if (x.left == null)
				return x.right;
			Node t = x;
			x = min(t.right);
			x.right = deleteMin(t.right);
			x.left = t.left;
		}
		x.N = size(x.left) + size(x.right) + 1;
		return x;
	}
 
	/***********************************************************************
	 * Min, max, floor, and ceiling
	 ***********************************************************************/
	public Key min()
	{
		if (isEmpty())
			return null;
		return min(root).key;
	}
 
	private Node min(Node x)
	{
		if (x.left == null)
			return x;
		else
			return min(x.left);
	}
 
	public Key max()
	{
		if (isEmpty())
			return null;
		return max(root).key;
	}
 
	private Node max(Node x)
	{
		if (x.right == null)
			return x;
		else
			return max(x.right);
	}
 
	public Key floor(Key key)
	{
		Node x = floor(root, key);
		if (x == null)
			return null;
		else
			return x.key;
	}
 
	private Node floor(Node x, Key key)
	{
		if (x == null)
			return null;
		int cmp = key.compareTo(x.key);
		if (cmp == 0)
			return x;
		if (cmp < 0)
			return floor(x.left, key);
		Node t = floor(x.right, key);
		if (t != null)
			return t;
		else
			return x;
	}
 
	/***********************************************************************
	 * Rank and selection
	 ***********************************************************************/
	public Key select(int k)
	{
		if (k < 0 || k >= size())
			return null;
		Node x = select(root, k);
		return x.key;
	}
 
	// Return key of rank k.
	private Node select(Node x, int k)
	{
		if (x == null)
			return null;
		int t = size(x.left);
		if (t > k)
			return select(x.left, k);
		else if (t < k)
			return select(x.right, k - t - 1);
		else
			return x;
	}
 
	public int rank(Key key)
	{
		return rank(key, root);
	}
 
	// Number of keys in the subtree less than key.
	private int rank(Key key, Node x)
	{
		if (x == null)
			return 0;
		int cmp = key.compareTo(x.key);
		if (cmp < 0)
			return rank(key, x.left);
		else if (cmp > 0)
			return 1 + size(x.left) + rank(key, x.right);
		else
			return size(x.left);
	}
 
	/***********************************************************************
	 * Range count and range search.
	 ***********************************************************************/
	public Iterable<Key> keys()
	{
		return keys(min(), max());
	}
 
	public Iterable<Key> keys(Key lo, Key hi)
	{
		Queue<Key> queue = new Queue<Key>();
		keys(root, queue, lo, hi);
		return queue;
	}
 
	private void keys(Node x, Queue<Key> queue, Key lo, Key hi)
	{
		if (x == null)
			return;
		int cmplo = lo.compareTo(x.key);
		int cmphi = hi.compareTo(x.key);
		if (cmplo < 0)
			keys(x.left, queue, lo, hi);
		if (cmplo <= 0 && cmphi >= 0)
			queue.enqueue(x.key);
		if (cmphi > 0)
			keys(x.right, queue, lo, hi);
	}
 
	public int size(Key lo, Key hi)
	{
		if (lo.compareTo(hi) > 0)
			return 0;
		if (contains(hi))
			return rank(hi) - rank(lo) + 1;
		else
			return rank(hi) - rank(lo);
	}
 
	// height of this BST (one-node tree has height 0)
	public int height()
	{
		return height(root);
	}
 
	private int height(Node x)
	{
		if (x == null)
			return -1;
		return 1 + Math.max(height(x.left), height(x.right));
	}
 
	// level order traversal
	public Iterable<Key> levelOrder()
	{
		Queue<Key> keys = new Queue<Key>();
		Queue<Node> queue = new Queue<Node>();
		queue.enqueue(root);
		while (!queue.isEmpty())
		{
			Node x = queue.dequeue();
			if (x == null)
				continue;
			keys.enqueue(x.key);
			queue.enqueue(x.left);
			queue.enqueue(x.right);
		}
		return keys;
	}
 
	/*************************************************************************
	 * Check integrity of BST data structure
	 *************************************************************************/
	private boolean check()
	{
		if (!isBST())
			System.out.println("Not in symmetric order");
		if (!isSizeConsistent())
			System.out.println("Subtree counts not consistent");
		if (!isRankConsistent())
			System.out.println("Ranks not consistent");
		return isBST() && isSizeConsistent() && isRankConsistent();
	}
 
	// does this binary tree satisfy symmetric order?
	// Note: this test also ensures that data structure is a binary tree since
	// order is strict
	private boolean isBST()
	{
		return isBST(root, null, null);
	}
 
	// is the tree rooted at x a BST with all keys strictly between min and max
	// (if min or max is null, treat as empty constraint)
	// Credit: Bob Dondero's elegant solution
	private boolean isBST(Node x, Key min, Key max)
	{
		if (x == null)
			return true;
		if (min != null && x.key.compareTo(min) <= 0)
			return false;
		if (max != null && x.key.compareTo(max) >= 0)
			return false;
		return isBST(x.left, min, x.key) && isBST(x.right, x.key, max);
	}
 
	// are the size fields correct?
	private boolean isSizeConsistent()
	{
		return isSizeConsistent(root);
	}
 
	private boolean isSizeConsistent(Node x)
	{
		if (x == null)
			return true;
		if (x.N != size(x.left) + size(x.right) + 1)
			return false;
		return isSizeConsistent(x.left) && isSizeConsistent(x.right);
	}
 
	// check that ranks are consistent
	private boolean isRankConsistent()
	{
		for (int i = 0; i < size(); i++)
			if (i != rank(select(i)))
				return false;
		for (Key key : keys())
			if (key.compareTo(select(rank(key))) != 0)
				return false;
		return true;
	}
 
	public Iterable<Key> postOrder()
	{
		Queue<Key> keys = new Queue<Key>();
		postOrder(root, keys);
		return keys;
	}
 
	public void postOrder(Node root, Queue<Key> keys)
	{
		if(root == null) 
			return;
		postOrder(root.left,keys);
		postOrder(root.right,keys);
		keys.enqueue(root.key);
 
	}
 
	public Iterable<Key> inOrder()
	{
		Queue<Key> keys = new Queue<Key>();
		inOrder(root, keys);
		return keys;
	}
 
	public void inOrder(Node root, Queue<Key> keys)
	{
		if(root == null) 
			return;
		inOrder(root.left,keys);
		keys.enqueue(root.key);
		inOrder(root.right,keys);
 
 
	}
 
	public Iterable<Key> preOrder()
	{
		Queue<Key> keys = new Queue<Key>();
		preOrder(root, keys);
		return keys;
	}
 
	public void preOrder(Node root, Queue<Key> keys)
	{
		if(root == null) 
			return;
		keys.enqueue(root.key);
		preOrder(root.left,keys);
		preOrder(root.right,keys);	
	}
 
 
}

BstApp

import java.util.Scanner;
 
public class BstApp
{
 
	public static void main(String[] args)
	{
		Scanner input = new Scanner("I E M C G K O");
 
		BST<String, Integer> st = new BST<String, Integer>();
		for (int i = 0; input.hasNext(); i++)
		{
			String key = input.next();
			st.put(key, i);
		}
 
//		for (String s : st.levelOrder())
//			System.out.print(s + " ");
//		System.out.println("\n");
 
		System.out.println("Pre Order:");
		for (String s : st.preOrder())
			System.out.print(s + " ");
		System.out.println("\n");
 
		System.out.println("In Order:");
		for (String s : st.inOrder())
			System.out.print(s + " ");
		System.out.println("\n");
 
		System.out.println("Post Order:");
		for (String s : st.postOrder())
			System.out.print(s + " ");
		System.out.println("\n");
 
		input.close();
	}
 
}

JUnit Test

package test;
 
import static org.junit.Assert.assertEquals;
 
import java.util.Scanner;
 
import org.junit.Before;
import org.junit.Test;
 
import edu.princeton.cs.algs4.BST;
import edu.princeton.cs.algs4.Queue;
 
public class BSTTest
{
	private BST<String, Integer> actualBST;
	private Queue<Integer> expectedQueue;
 
	@Before
	public void setUp() throws Exception
	{
		expectedQueue = new Queue<Integer>();
		actualBST = new BST<String, Integer>();
 
		actualBST.put("Four", 4);
		actualBST.put("Two", 2);
		actualBST.put("Six", 6);
		actualBST.put("One", 1);
		actualBST.put("Three", 3);
		actualBST.put("Five", 5);
		actualBST.put("Seven", 7);			
	}
 
	@Test
	public void testLevelOrder()
	{
		expectedQueue.enqueue(4);
		expectedQueue.enqueue(2);
		expectedQueue.enqueue(6);
		expectedQueue.enqueue(1);
		expectedQueue.enqueue(3);
		expectedQueue.enqueue(5);
		expectedQueue.enqueue(7);
 
		for(Integer i : expectedQueue)
			assertEquals(i, actualBST.levelOrder());
	}
 
	@Test
	public void testPostOrder()
	{
		expectedQueue.enqueue(1);
		expectedQueue.enqueue(3);
		expectedQueue.enqueue(2);
		expectedQueue.enqueue(5);
		expectedQueue.enqueue(7);
		expectedQueue.enqueue(6);
		expectedQueue.enqueue(4);
 
		for(Integer i : expectedQueue)
			assertEquals(i, actualBST.postOrder());
	}
 
	@Test
	public void testInOrder()
	{
		expectedQueue.enqueue(1);
		expectedQueue.enqueue(2);
		expectedQueue.enqueue(3);
		expectedQueue.enqueue(4);
		expectedQueue.enqueue(5);
		expectedQueue.enqueue(6);
		expectedQueue.enqueue(7);
 
		for(Integer i : expectedQueue)
			assertEquals(i, actualBST.inOrder());
	}
 
	@Test
	public void testPreOrder()
	{
		expectedQueue.enqueue(4);
		expectedQueue.enqueue(2);
		expectedQueue.enqueue(1);
		expectedQueue.enqueue(3);
		expectedQueue.enqueue(6);
		expectedQueue.enqueue(5);
		expectedQueue.enqueue(7);
 
		for(Integer i : expectedQueue)
			assertEquals(i, actualBST.preOrder());
	}
 
 
}

The JUnit test has 3 errors, all because I can't call those methods.

Any advice on how to solve this problem would be much appreciated.

and it wouldn't let me call any of the order methods

What does that mean? You got an error? If so, post the error.

Sorry, I didn't mention the error I received. Anyway the message was in the case of inOrder "The method inOrder() is undefined for the type BST<String, Integer>" Eclipses allows me to add a cast to it, but adding a cast just doesn't make any sense to me because its already a BST, why cast it to a BST. I've tried doing what eclipse recommended and it results in the same error.