| package junit.swingui; |
| |
| import java.util.*; |
| import javax.swing.event.*; |
| import javax.swing.tree.*; |
| |
| import junit.extensions.*; |
| import junit.framework.*; |
| |
| /** |
| * A tree model for a Test. |
| */ |
| class TestTreeModel implements TreeModel { |
| private Test fRoot; |
| private Vector fModelListeners= new Vector(); |
| private Hashtable fFailures= new Hashtable(); |
| private Hashtable fErrors= new Hashtable(); |
| private 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. |
| */ |
| TestSuite isTestSuite(Object node) { |
| if (node instanceof TestSuite) |
| return (TestSuite)node; |
| if (node instanceof TestDecorator) { |
| Test baseTest= ((TestDecorator)node).getTest(); |
| return isTestSuite(baseTest); |
| } |
| 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(); |
| } |
| } |