org.eclipse.jdt.ui.tests/JUnit/junit/swingui/TestTreeModel.java

package junit.swingui;

import java.util.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import junit.framework.*;

/**
 * A tree model for a Test.
 */
class TestTreeModel implements TreeModel {
	Test fRoot;
	Vector fModelListeners= new Vector();
	Hashtable fFailures= new Hashtable();
	Hashtable fErrors= new Hashtable();
	Hashtable fRunTests= new Hashtable();
	
/**
 * Constructs a tree model with the given test as its root.
 */
public TestTreeModel(Test root) {
	super();
	fRoot= root;
}

/**
 * adds a TreeModelListener
 */
public void addTreeModelListener(TreeModelListener l) {
	if (!fModelListeners.contains(l))
		fModelListeners.addElement(l);
}
/**
 * Removes a TestModelListener
 */
public void removeTreeModelListener(TreeModelListener l) {
	fModelListeners.removeElement(l);
}
/**
 * Finds the path to a test. Returns the index of the test in its
 * parent test suite.
 */
public int findTest(Test target, Test node, Vector path) {
	if (target.equals(node)) 
		return 0;
		
	TestSuite suite= isTestSuite(node);
	for (int i= 0; i < getChildCount(node); i++) {
		Test t= suite.testAt(i); 
		int index= findTest(target, t, path);
		if (index >= 0) {
			path.insertElementAt(node, 0);
			if (path.size() == 1)
				return i;
			return index;
		}
	}
	return -1;
}
/**
 * Fires a node changed event
 */
public void fireNodeChanged(TreePath path, int index) {
	int[] indices= {index};
	Object[] changedChildren= {getChild(path.getLastPathComponent(), index)};
	TreeModelEvent event= new TreeModelEvent(this, path, indices, changedChildren);
	
	Enumeration e= fModelListeners.elements();
	while (e.hasMoreElements()) { 
		TreeModelListener l= (TreeModelListener) e.nextElement();
		l.treeNodesChanged(event);
	}	
}
/**
 * Gets the test at the given index
 */
public Object getChild(Object parent, int index) {
	TestSuite suite= isTestSuite(parent);
	if (suite != null) 
		return suite.testAt(index);
	return null; 
}
/**
 * Gets the number of tests.
 */
public int getChildCount(Object parent) {
	TestSuite suite= isTestSuite(parent);
	if (suite != null) 
		return suite.testCount();
	return 0;
}
/**
 * Gets the index of a test in a test suite
 */
public int getIndexOfChild(Object parent, Object child) {
	TestSuite suite= isTestSuite(parent);
	if (suite != null) {
		int i= 0;
		for (Enumeration e= suite.tests(); e.hasMoreElements(); i++) {
			if (child.equals((Test)e.nextElement()))
				return i;
		}
	}
	return -1; 
}
/**
 * Returns the root of the tree
 */
public Object getRoot() {
	return fRoot;
}
/**
 * Tests if the test is a leaf.
 */
public boolean isLeaf(Object node) {
	return isTestSuite(node) == null;
}
/**
 * Tests if the node is a TestSuite.
 */
protected TestSuite isTestSuite(Object node) {
	if (node instanceof TestSuite) 
		return (TestSuite)node;
	return null;
}
/**
 * Called when the value of the model object was changed in the view
 */
public void valueForPathChanged(TreePath path, Object newValue) {
	// we don't support direct editing of the model
	System.out.println("TreeModel.valueForPathChanged: not implemented");
}
/**
 * Remembers a test failure
 */
void addFailure(Test t) {
	fFailures.put(t, t);
}
/**
 * Remembers a test error
 */
void addError(Test t) {
	fErrors.put(t, t);
}
/**
 * Remembers that a test was run
 */
void addRunTest(Test t) {
	fRunTests.put(t, t);
}
/**
 * Returns whether a test was run
 */
boolean wasRun(Test t) {
	return fRunTests.get(t) != null;
}
/**
 * Tests whether a test was an error
 */
boolean isError(Test t) {
	return (fErrors != null) && fErrors.get(t) != null;
}
/**
 * Tests whether a test was a failure
 */
boolean isFailure(Test t) {
	return (fFailures != null) && fFailures.get(t) != null;
}
/**
 * Resets the test results
 */
void resetResults() {
	fFailures= new Hashtable();
	fRunTests= new Hashtable();
	fErrors= new Hashtable();
}

}