Welcome to the Java Programming Forums


The professional, friendly Java community. 21,500 members and growing!


The Java Programming Forums are a community of Java programmers from all around the World. Our members have a wide range of skills and they all have one thing in common: A passion to learn and code Java. We invite beginner Java programmers right through to Java professionals to post here and share your knowledge. Become a part of the community, help others, expand your knowledge of Java and enjoy talking with like minded people. Registration is quick and best of all free. We look forward to meeting you.


>> REGISTER NOW TO START POSTING


Members have full access to the forums. Advertisements are removed for registered users.

Results 1 to 3 of 3

Thread: JUnit Test Confusion.

  1. #1
    Junior Member Spencer4908's Avatar
    Join Date
    Jul 2014
    Location
    UTAH, USA
    Posts
    12
    My Mood
    Cheerful
    Thanks
    1
    Thanked 1 Time in 1 Post

    Default 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.


  2. #2
    Super Moderator
    Join Date
    Jun 2013
    Location
    So. Maryland, USA
    Posts
    5,520
    My Mood
    Mellow
    Thanks
    215
    Thanked 697 Times in 679 Posts

    Default Re: JUnit Test Confusion.

    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.

  3. #3
    Junior Member Spencer4908's Avatar
    Join Date
    Jul 2014
    Location
    UTAH, USA
    Posts
    12
    My Mood
    Cheerful
    Thanks
    1
    Thanked 1 Time in 1 Post

    Default Re: JUnit Test Confusion.

    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.

Similar Threads

  1. Using Junit testing to test
    By egreenhorn in forum What's Wrong With My Code?
    Replies: 1
    Last Post: June 15th, 2014, 11:29 AM
  2. Using JUnit to test JSwing
    By Lerox in forum Java Theory & Questions
    Replies: 0
    Last Post: March 5th, 2014, 02:21 PM
  3. Exception in JUnit test (easy question)
    By opium in forum Exceptions
    Replies: 1
    Last Post: February 14th, 2012, 08:09 AM
  4. validate XMl by using XMLUnit and JUnit test?
    By beruska in forum What's Wrong With My Code?
    Replies: 0
    Last Post: November 16th, 2011, 07:20 AM
  5. JUnit test for ER
    By raphytaffy in forum What's Wrong With My Code?
    Replies: 3
    Last Post: September 20th, 2010, 09:26 PM