btapplettest.java

平衡二叉树 生成

import junit.framework.TestCase;

//public class BTAppletTest extends TestCase {
	import junit.framework.*;

	public class BTAppletTest extends TestCase {
	    
	    public static void main(String args[]){
	        junit.textui.TestRunner.run(suite());
	    }
	    
	    public BTAppletTest(String testName) {
	        super(testName);
	    }
	    
	    protected void setUp() throws Exception {
	    }
	    
	    protected void tearDown() throws Exception {
	    }
	    
	    public static TestSuite suite() {
	        TestSuite suite = new TestSuite(BTAppletTest.class);
	        return suite;
	    }

	    //****************DELETE FUNCTION TEST CASES**************************
	    //****************Test case #1**********************
	    /*Deepti Delete*/
	    //Delete the rootnode- Pass

	    public void testDeleteNode() {
			BTTree tree = new BTTree();
			BTData dataAdd = new BTData("10");
			BTData dataDel = new BTData("10");
			tree.insert(dataAdd);
			BTNode removed = tree.remove(dataDel);
	        assertEquals(removed.data.key,"10");
	        
	    }
	    
//	  ****************Test case #2**********************
	    /*Clarinda Delete*/
	    //Delete a left node from the tree-Pass
	    public void testDeleteLeftNode() {
			BTTree tree = new BTTree();
			BTData dataAdd1 = new BTData("5");
			BTData dataAdd2 = new BTData("10");
			BTData dataAdd3 = new BTData("15");
			BTData dataDel = new BTData("5");
			tree.insert(dataAdd1);
			tree.insert(dataAdd2);
			tree.insert(dataAdd3);
			BTNode removed = tree.remove(dataDel);
	        assertEquals(removed.data.key,"5");
	        
	    }

//	  ****************Test case #3**********************
	    /*Clarinda Delete*/
	    //Delete an negative node from the tree-Fail
	    public void testDeleteNegativeNode(){
	    	BTTree tree = new BTTree();
			BTData dataAdd1 = new BTData("5");
			BTData dataAdd2 = new BTData("10");
			BTData dataAdd3 = new BTData("-15");
			BTData dataDel = new BTData("-15");
			tree.insert(dataAdd1);
			tree.insert(dataAdd2);
			tree.insert(dataAdd3);
			BTNode removed = tree.remove(dataDel);
	        assertEquals(removed.data.key,"15");
	    }
	    
//	  ****************Test case #4**********************
	    /*Priya Delete*/
	    //Delete a right node from the tree-Pass
	    public void testDeleteRightNode() {
			BTTree tree = new BTTree();
			BTData dataAdd1 = new BTData("5");
			BTData dataAdd2 = new BTData("10");
			BTData dataAdd3 = new BTData("15");
			BTData dataDel = new BTData("15");
			tree.insert(dataAdd1);
			tree.insert(dataAdd2);
			tree.insert(dataAdd3);
			BTNode removed = tree.remove(dataDel);
	        assertEquals(removed.data.key,"15");
	        
	    }
	    
//	  ****************Test case #5**********************
	    /*Priya Delete*/
	    //Input a null node to be deleted-Pass
	    public void testDeleteNullNode() {
			BTTree tree = new BTTree();
			BTData dataAdd1 = new BTData("5");
			BTData dataAdd2 = new BTData("10");
			BTData dataAdd3 = new BTData("15");
			BTData dataDel = new BTData("");
			tree.insert(dataAdd1);
			tree.insert(dataAdd2);
			tree.insert(dataAdd3);
			
			BTNode remove = tree.remove(dataDel);	
	        assertEquals(remove,null);
	        
	    }

//	  ****************INSERT FUNCTION TEST CASES**************************
//	  ****************Test case #6**********************
	    /*Deepti Insert*/
	    // Insert Dulpicate node-Pass
	        public void testInsertDuplicateNode(){
			BTTree tree = new BTTree();
			BTData dataAddFirst = new BTData("10");
			BTData dataAddSecond = new BTData("10");
			tree.insert(dataAddFirst);
			BTNode retVal = tree.insert(dataAddSecond);
	        assertEquals(retVal,null);
	    }
	        
//	      ****************Test case #7**********************
	        /*Clarinda Insert*/
	        //Insert a node to an Empty Tree- Pass
	        public void testInsertNodeToEmptyTree(){
	    		BTTree tree = new BTTree();
	    		BTData dataAddFirst = new BTData("10");
	    		BTNode retVal = tree.insert(dataAddFirst);
	    	    assertEquals(retVal.data.key,"10");
	        }
	        
//	      ****************Test case #8**********************
	        /*Priya Insert*/
	        //Insert Invalid node -Fail
	      public void testInsertInvalidNode(){
	    		BTTree tree = new BTTree();
	    		BTData dataAddFirst = new BTData("-10");
	    		BTData dataAddSecond = new BTData("-5");
	    		tree.insert(dataAddFirst);
	                tree.insert(dataAddSecond);
	    		BTNode retVal = tree.locate(dataAddSecond);
	            assertEquals(retVal.data.key,null);
	        }


//	    ****************FIND FUNCTION TEST CASES**************************    
//	  ****************Test case #9**********************
	        /*Deepti Find*/
	        // Node not Found - Pass
	    public void testFindNode(){
			BTTree tree = new BTTree();
			BTData dataAddFirst = new BTData("10");
			BTData dataAddSecond = new BTData("12");
			tree.insert(dataAddFirst);
			BTNode retVal = tree.locate(dataAddSecond);
	        assertEquals(retVal,null);
	    }
	    
//	  ****************Test case #10**********************
	    /*Clarinda Find*/
	    //Node is found -Pass
	    public void testFindNodeFound(){
			BTTree tree = new BTTree();
			BTData dataAddFirst = new BTData("10");
			BTData dataAddSecond = new BTData("12");
			tree.insert(dataAddFirst);
			tree.insert(dataAddSecond);
			BTNode retVal = tree.locate(dataAddSecond);
	        assertEquals(retVal.data.key,"12");
	    }

	    
//	  ****************DELETEALL FUNCTION TEST CASES**************************
	    //  ****************Test case #11**********************
	    /*Deepti*/
	    //Delete all from a non-empty tree-Pass
	    public void testDeleteAll(){
			BTTree tree = new BTTree();
			BTData dataAddFirst = new BTData("10");
			BTData dataAddSecond = new BTData("12");
			BTData dataAddThird = new BTData("5");
			tree.insert(dataAddFirst);
			tree.insert(dataAddSecond);
			tree.insert(dataAddThird);
			tree.delall();
	        assertEquals(tree.locate(dataAddFirst), null);    	
	    }
	    
	    
//	  ****************Test case #12**********************
	    /*Priya DeleteAll-Empty Tree*/
	    //Delete all from an empty tree-Pass
		public void testDeleteAllEmptyTree(){
			BTTree tree = new BTTree();
			tree.delall();
			
	        assertEquals(tree.nodecount,0);    	
	    }

	  
//	  ****************TRAVERSE FUNCTION TEST CASES**************************
		/*Deepti Traverse-Inorder Traversal-Non-Empty Tree*/
	    //In-Order Traversal in a non-empty tree-Pass
		//  ****************Test case #13**********************
	    public void testInOrderTraversal() {
			BTTree tree = new BTTree();
			tree.AVLbalanced = true;
			BTData dataAddFirst = new BTData("10");
			BTData dataAddSecond = new BTData("5");
			BTData dataAddThird = new BTData("12");
			BTNode nodeFirst = tree.insert(dataAddFirst);
			BTNode nodeSecond = tree.insert(dataAddSecond);
			BTNode nodeThird = tree.insert(dataAddThird);
			System.out.println("root: " + tree.root.data.key);
			System.out.println("last in order:" + tree.root.lastInO().data.key);
	    	assertEquals(true,true);
			
	    }
	    
	}