*  Licensed to the Apache Software Foundation (ASF) under one or more

*  contributor license agreements.  See the NOTICE file distributed with

*  this work for additional information regarding copyright ownership.

*  The ASF licenses this file to You under the Apache License, Version 2.0

*  (the "License"); you may not use this file except in compliance with

*  the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

*  Unless required by applicable law or agreed to in writing, software

*  distributed under the License is distributed on an "AS IS" BASIS,

*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

*  See the License for the specific language governing permissions and

*  limitations under the License.

*/

* @author Anton Avtamonov, Alexander T. Simbirtsev

*/

    protected JTree tree;

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        tree = new JTree();

        tree.setCellRenderer(new DefaultTreeCellRenderer() {

            @Override

            public FontMetrics getFontMetrics(Font f) {

                return JTreeTest.this.getFontMetrics(f, 10, 10);

            }

        });

        propertyChangeController = new PropertyChangeController();

        tree.addPropertyChangeListener(propertyChangeController);

    }

    @Override

    protected void tearDown() throws Exception {

        tree = null;

        propertyChangeController = null;

        super.tearDown();

    }

    public void testTreeSelectionRedirector() throws Exception {

        assertNull(tree.selectionRedirector);

        DefaultTreeSelectionModel model = (DefaultTreeSelectionModel) tree.getSelectionModel();

        assertFalse(hasListener(model.getTreeSelectionListeners(),

                JTree.TreeSelectionRedirector.class));

        final Marker marker = new Marker();

        tree.addTreeSelectionListener(new TreeSelectionListener() {

            public void valueChanged(final TreeSelectionEvent e) {

                marker.setAuxiliary(e);

            }

        });

        assertNotNull(tree.selectionRedirector);

        assertTrue(hasListener(model.getTreeSelectionListeners(),

                JTree.TreeSelectionRedirector.class));

        TreePath path = new TreePath("root");

        TreePath oldLead = new TreePath("old_lead");

        TreePath newLead = new TreePath("new_lead");

        tree.selectionRedirector.valueChanged(new TreeSelectionEvent("any_source", path, true,

                oldLead, newLead));

        assertNotNull(marker.getAuxiliary());

        TreeSelectionEvent redirectedEvent = (TreeSelectionEvent) marker.getAuxiliary();

        assertSame(tree, redirectedEvent.getSource());

        assertSame(path, redirectedEvent.getPath());

        assertTrue(redirectedEvent.isAddedPath());

        assertSame(oldLead, redirectedEvent.getOldLeadSelectionPath());

        assertSame(newLead, redirectedEvent.getNewLeadSelectionPath());

        DefaultTreeSelectionModel newModel = new DefaultTreeSelectionModel();

        tree.setSelectionModel(newModel);

        assertTrue(hasListener(newModel.getTreeSelectionListeners(),

                JTree.TreeSelectionRedirector.class));

        tree.setSelectionModel(null);

        assertTrue(hasListener(((DefaultTreeSelectionModel) tree.getSelectionModel())

                .getTreeSelectionListeners(), JTree.TreeSelectionRedirector.class));

    }

    public void testJTree() {

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertTrue(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertFalse(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.cellRenderer);

        assertNull(tree.cellEditor);

        assertNotNull(tree.treeModel);

        assertNotNull(tree.treeModelListener);

    }

    public void testJTreeTreeModel() {

        DefaultTreeModel model = new DefaultTreeModel(new DefaultMutableTreeNode("root"));

        tree = new JTree(model);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertTrue(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertFalse(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertEquals(model, tree.treeModel);

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

        tree = new JTree((TreeModel) null);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertTrue(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertFalse(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNull(tree.treeModel);

        if (isHarmony()) {

            assertNotNull(tree.treeModelListener);

        } else {

            assertNull(tree.treeModelListener);

        }

    }

    public void testJTreeTreeNodeBoolean() {

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");

        tree = new JTree(root, true);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertTrue(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertFalse(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertEquals(root, tree.treeModel.getRoot());

        assertTrue(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

        tree = new JTree(root, false);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertTrue(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertFalse(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertEquals(root, tree.treeModel.getRoot());

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

        tree = new JTree(null, false);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertTrue(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertFalse(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertNull(tree.treeModel.getRoot());

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

    }

    public void testJTreeTreeNode() {

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");

        tree = new JTree(root);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertTrue(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertFalse(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertEquals(root, tree.treeModel.getRoot());

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

        tree = new JTree((TreeNode) null);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertTrue(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertFalse(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertNull(tree.treeModel.getRoot());

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

    }

    public void testJTreeObjectArray() {

        Object[] nodes = new Object[] { "node1", "node2", "node3" };

        tree = new JTree(nodes);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertFalse(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertTrue(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertNotNull(tree.treeModel.getRoot());

        assertEquals(3, tree.treeModel.getChildCount(tree.treeModel.getRoot()));

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

        tree = new JTree((Object[]) null);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertFalse(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertTrue(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertNotNull(tree.treeModel.getRoot());

        assertEquals(0, tree.treeModel.getChildCount(tree.treeModel.getRoot()));

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

    }

    public void testJTreeVector() {

        Vector<String> nodes = new Vector<String>();

        nodes.add("node1");

        nodes.add("node2");

        nodes.add("node3");

        tree = new JTree(nodes);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertFalse(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertTrue(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertNotNull(tree.treeModel.getRoot());

        assertEquals(3, tree.treeModel.getChildCount(tree.treeModel.getRoot()));

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

        tree = new JTree((Vector) null);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertFalse(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertTrue(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertNotNull(tree.treeModel.getRoot());

        assertEquals(0, tree.treeModel.getChildCount(tree.treeModel.getRoot()));

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

    }

    public void testJTreeHashtable() {

        Hashtable<String, String> nodes = new Hashtable<String, String>();

        nodes.put("node1", "node1");

        nodes.put("node2", "node2");

        nodes.put("node3", "node3");

        tree = new JTree(nodes);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertFalse(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertTrue(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertNotNull(tree.treeModel.getRoot());

        assertEquals(3, tree.treeModel.getChildCount(tree.treeModel.getRoot()));

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

        tree = new JTree((Hashtable) null);

        assertFalse(tree.editable);

        assertFalse(tree.invokesStopCellEditing);

        assertFalse(tree.largeModel);

        assertFalse(tree.rootVisible);

        assertEquals(0, tree.rowHeight);

        assertTrue(tree.scrollsOnExpand);

        assertTrue(tree.showsRootHandles);

        assertEquals(2, tree.toggleClickCount);

        assertEquals(20, tree.visibleRowCount);

        assertNotNull(tree.selectionModel);

        assertNull(tree.selectionRedirector);

        assertNotNull(tree.treeModel);

        assertNotNull(tree.treeModel.getRoot());

        assertEquals(0, tree.treeModel.getChildCount(tree.treeModel.getRoot()));

        assertFalse(((DefaultTreeModel) tree.treeModel).asksAllowsChildren());

        assertNotNull(tree.treeModelListener);

    }

    public void testGetAccessibleContext() {

        assertNull(tree.accessibleContext);

        assertNotNull(tree.getAccessibleContext());

        assertSame(tree.accessibleContext, tree.getAccessibleContext());

    }

    public void testGetToolTipTextMouseEvent() {

        tree.setToolTipText("tip");

        tree.cellRenderer = new DefaultTreeCellRenderer() {

            @Override

            public String getToolTipText() {

                return "renderer tip";

            }

        };

        assertEquals("renderer tip", tree.getToolTipText(new MouseEvent(tree, 0, 0, 0, 0, 0, 0,

                false)));

        assertNull(tree.getToolTipText(null));

    }

    public void testGetUIClassID() {

        assertEquals("TreeUI", tree.getUIClassID());

    }

    public void testSetAddRemoveSelectionInterval() {

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");

        DefaultMutableTreeNode child1 = new DefaultMutableTreeNode("child1");

        DefaultMutableTreeNode child11 = new DefaultMutableTreeNode("child11");

        DefaultMutableTreeNode child111 = new DefaultMutableTreeNode("child111");

        DefaultMutableTreeNode child2 = new DefaultMutableTreeNode("child2");

        DefaultMutableTreeNode child21 = new DefaultMutableTreeNode("child21");

        root.add(child1);

        child1.add(child11);

        child11.add(child111);

        root.add(child2);

        child2.add(child21);

        tree.setModel(new DefaultTreeModel(root));

        TreePath rootPath = new TreePath(root);

        TreePath path1 = rootPath.pathByAddingChild(child1);

        TreePath path11 = path1.pathByAddingChild(child11);

        TreePath path2 = rootPath.pathByAddingChild(child2);

        assertEquals(0, tree.getSelectionCount());

        tree.addSelectionInterval(0, 0);

        assertEquals(1, tree.getSelectionCount());

        tree.addSelectionInterval(1, 1);

        assertEquals(2, tree.getSelectionCount());

        tree.addSelectionInterval(-20, 20);

        assertEqualsIgnoreOrder(new TreePath[] { rootPath, path1, path2 }, tree

                .getSelectionPaths());

        tree.expandPath(path1);

        assertEqualsIgnoreOrder(new TreePath[] { rootPath, path1, path2 }, tree

                .getSelectionPaths());

        tree.addSelectionInterval(1, 2);

        assertEqualsIgnoreOrder(new TreePath[] { rootPath, path1, path2, path11 }, tree

                .getSelectionPaths());

        tree.removeSelectionInterval(0, 1);

        assertEqualsIgnoreOrder(new TreePath[] { path11, path2 }, tree.getSelectionPaths());

        tree.removeSelectionInterval(2, 2);

        assertEqualsIgnoreOrder(new TreePath[] { path2 }, tree.getSelectionPaths());

        tree.removeSelectionInterval(0, 2);

        assertEqualsIgnoreOrder(new TreePath[] { path2 }, tree.getSelectionPaths());

        tree.removeSelectionInterval(-1, 10);

        assertNull(tree.getSelectionPaths());

        tree.setSelectionInterval(3, 1);

        assertEqualsIgnoreOrder(new TreePath[] { path1, path11, path2 }, tree

                .getSelectionPaths());

        tree.setSelectionInterval(2, 2);

        assertEqualsIgnoreOrder(new TreePath[] { path11 }, tree.getSelectionPaths());

    }

    public void testAddRemoveSelectionPathPathsRowRows() {

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");

        DefaultMutableTreeNode child1 = new DefaultMutableTreeNode("child1");

        DefaultMutableTreeNode child11 = new DefaultMutableTreeNode("child11");

        DefaultMutableTreeNode child111 = new DefaultMutableTreeNode("child111");

        DefaultMutableTreeNode child2 = new DefaultMutableTreeNode("child2");

        DefaultMutableTreeNode child21 = new DefaultMutableTreeNode("child21");

        root.add(child1);

        child1.add(child11);

        child11.add(child111);

        root.add(child2);

        child2.add(child21);

        tree.setModel(new DefaultTreeModel(root));

        TreePath rootPath = new TreePath(root);

        TreePath path1 = rootPath.pathByAddingChild(child1);

        TreePath path11 = path1.pathByAddingChild(child11);

        TreePath path111 = path11.pathByAddingChild(child111);

        TreePath path2 = rootPath.pathByAddingChild(child2);

        TreePath path21 = path2.pathByAddingChild(child21);

        assertEquals(0, tree.getSelectionCount());

        tree.addSelectionPath(path1);

        assertEqualsIgnoreOrder(new TreePath[] { path1 }, tree.getSelectionPaths());

        tree.addSelectionPaths(new TreePath[] { rootPath, path11 });

        assertEqualsIgnoreOrder(new TreePath[] { path1, rootPath, path11 }, tree

                .getSelectionPaths());

        TreePath unexistedPath = rootPath.pathByAddingChild(new DefaultMutableTreeNode(

                "unexisted"));

        tree.addSelectionPath(unexistedPath);

        assertEqualsIgnoreOrder(new TreePath[] { path1, rootPath, path11, unexistedPath }, tree

                .getSelectionPaths());

        tree.removeSelectionPaths(new TreePath[] { rootPath, unexistedPath });

        assertEqualsIgnoreOrder(new TreePath[] { path11, path1 }, tree.getSelectionPaths());

        tree.removeSelectionPath(path11);

        assertEqualsIgnoreOrder(new TreePath[] { path1 }, tree.getSelectionPaths());

        tree.expandPath(path2);

        tree.addSelectionRows(new int[] { 3, 4 });

        assertEqualsIgnoreOrder(new TreePath[] { path1, path2, path21 }, tree

                .getSelectionPaths());

        tree.expandPath(path11);

        tree.addSelectionRows(new int[] { 0, 3 });

        assertEqualsIgnoreOrder(new TreePath[] { path1, path2, path21, rootPath, path111 },

                tree.getSelectionPaths());

        tree.removeSelectionRows(new int[] { 0, 2 });

        assertEqualsIgnoreOrder(new TreePath[] { path111, path2, path1, path21 }, tree

                .getSelectionPaths());

        tree.removeSelectionRow(3);

        assertEqualsIgnoreOrder(new TreePath[] { path2, path1, path21 }, tree

                .getSelectionPaths());

    }

    public void testAddGetRemoveTreeExpansionListener() {

        class ConcreteTreeExpansionListener implements TreeExpansionListener {

            public void treeCollapsed(TreeExpansionEvent e) {

            }

            public void treeExpanded(TreeExpansionEvent e) {

            }

        }

        ;

        TreeExpansionListener TreeExpansionListener1 = new ConcreteTreeExpansionListener();

        TreeExpansionListener TreeExpansionListener2 = new ConcreteTreeExpansionListener();

        TreeExpansionListener TreeExpansionListener3 = new ConcreteTreeExpansionListener();

        EventListener[] listenersArray = null;

        listenersArray = tree.getTreeExpansionListeners();

        int initialValue = listenersArray.length;

        tree.addTreeExpansionListener(TreeExpansionListener1);

        tree.addTreeExpansionListener(TreeExpansionListener2);

        tree.addTreeExpansionListener(TreeExpansionListener2);

        listenersArray = tree.getTreeExpansionListeners();

        assertEquals(initialValue + 3, listenersArray.length);

        tree.removeTreeExpansionListener(TreeExpansionListener1);

        tree.addTreeExpansionListener(TreeExpansionListener3);

        tree.addTreeExpansionListener(TreeExpansionListener3);

        listenersArray = tree.getTreeExpansionListeners();

        assertEquals(initialValue + 4, listenersArray.length);

        tree.removeTreeExpansionListener(TreeExpansionListener3);

        tree.removeTreeExpansionListener(TreeExpansionListener3);

        listenersArray = tree.getTreeExpansionListeners();

        assertEquals(initialValue + 2, listenersArray.length);

        tree.removeTreeExpansionListener(TreeExpansionListener2);

        tree.removeTreeExpansionListener(TreeExpansionListener2);

        listenersArray = tree.getTreeExpansionListeners();

        assertEquals(initialValue, listenersArray.length);

    }

    public void testAddGetRemoveTreeSelectionListener() {

        class ConcreteTreeSelectionListener implements TreeSelectionListener {

            public void valueChanged(TreeSelectionEvent e) {

            }

        }

        ;

        TreeSelectionListener TreeSelectionListener1 = new ConcreteTreeSelectionListener();

        TreeSelectionListener TreeSelectionListener2 = new ConcreteTreeSelectionListener();

        TreeSelectionListener TreeSelectionListener3 = new ConcreteTreeSelectionListener();

        EventListener[] listenersArray = null;

        listenersArray = tree.getTreeSelectionListeners();

        int initialValue = listenersArray.length;

        tree.addTreeSelectionListener(TreeSelectionListener1);

        tree.addTreeSelectionListener(TreeSelectionListener2);

        tree.addTreeSelectionListener(TreeSelectionListener2);

        listenersArray = tree.getTreeSelectionListeners();

        assertEquals(initialValue + 3, listenersArray.length);

        tree.removeTreeSelectionListener(TreeSelectionListener1);

        tree.addTreeSelectionListener(TreeSelectionListener3);

        tree.addTreeSelectionListener(TreeSelectionListener3);

        listenersArray = tree.getTreeSelectionListeners();

        assertEquals(initialValue + 4, listenersArray.length);

        tree.removeTreeSelectionListener(TreeSelectionListener3);

        tree.removeTreeSelectionListener(TreeSelectionListener3);

        listenersArray = tree.getTreeSelectionListeners();

        assertEquals(initialValue + 2, listenersArray.length);

        tree.removeTreeSelectionListener(TreeSelectionListener2);

        tree.removeTreeSelectionListener(TreeSelectionListener2);

        listenersArray = tree.getTreeSelectionListeners();

        assertEquals(initialValue, listenersArray.length);

    }

    public void testAddGetRemoveTreeWillExpandListener() {

            public void treeWillCollapse(TreeExpansionEvent e) throws ExpandVetoException {

            }

            public void treeWillExpand(TreeExpansionEvent e) throws ExpandVetoException {

            }

        }

        ;

        TreeWillExpandListener TreeWillExpandListener1 = new ConcreteTreeWillExpandListener();

        TreeWillExpandListener TreeWillExpandListener2 = new ConcreteTreeWillExpandListener();

        TreeWillExpandListener TreeWillExpandListener3 = new ConcreteTreeWillExpandListener();

        EventListener[] listenersArray = null;

        listenersArray = tree.getTreeWillExpandListeners();

        int initialValue = listenersArray.length;

        tree.addTreeWillExpandListener(TreeWillExpandListener1);

        tree.addTreeWillExpandListener(TreeWillExpandListener2);

        tree.addTreeWillExpandListener(TreeWillExpandListener2);

        listenersArray = tree.getTreeWillExpandListeners();

        assertEquals(initialValue + 3, listenersArray.length);

        tree.removeTreeWillExpandListener(TreeWillExpandListener1);

        tree.addTreeWillExpandListener(TreeWillExpandListener3);

        tree.addTreeWillExpandListener(TreeWillExpandListener3);

        listenersArray = tree.getTreeWillExpandListeners();

        assertEquals(initialValue + 4, listenersArray.length);

        tree.removeTreeWillExpandListener(TreeWillExpandListener3);

        tree.removeTreeWillExpandListener(TreeWillExpandListener3);

        listenersArray = tree.getTreeWillExpandListeners();

        assertEquals(initialValue + 2, listenersArray.length);

        tree.removeTreeWillExpandListener(TreeWillExpandListener2);

        tree.removeTreeWillExpandListener(TreeWillExpandListener2);

        listenersArray = tree.getTreeWillExpandListeners();

        assertEquals(initialValue, listenersArray.length);

    }

    public void testClearSelection() {

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");

        DefaultMutableTreeNode child1 = new DefaultMutableTreeNode("child1");

        root.add(child1);

        tree.setModel(new DefaultTreeModel(root));

        TreePath rootPath = new TreePath(root);

        TreePath path1 = rootPath.pathByAddingChild(child1);

        assertEquals(0, tree.getSelectionCount());

        assertEquals(0, tree.getSelectionModel().getSelectionCount());

        tree.addSelectionPaths(new TreePath[] { rootPath, path1 });

        assertEquals(2, tree.getSelectionCount());

        assertEquals(2, tree.getSelectionModel().getSelectionCount());

        tree.clearSelection();

        assertEquals(0, tree.getSelectionCount());

        assertEquals(0, tree.getSelectionModel().getSelectionCount());

    }

    public void testClearToggledPaths() {

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");

        DefaultMutableTreeNode child1 = new DefaultMutableTreeNode("child1");

        DefaultMutableTreeNode child11 = new DefaultMutableTreeNode("child11");

        DefaultMutableTreeNode child111 = new DefaultMutableTreeNode("child111");

        root.add(child1);

        child1.add(child11);

        child11.add(child111);

        tree.setModel(new DefaultTreeModel(root));

        TreePath rootPath = new TreePath(root);

        TreePath path1 = rootPath.pathByAddingChild(child1);

        assertTrue(tree.isExpanded(rootPath));

        assertFalse(tree.isExpanded(path1));

        tree.clearToggledPaths();

        assertFalse(tree.isExpanded(rootPath));

        assertFalse(tree.isExpanded(path1));

        tree.expandPath(path1);

        tree.clearToggledPaths();

        assertFalse(tree.isExpanded(rootPath));

        assertFalse(tree.isExpanded(path1));

    }

    public void testConvertValueToText() {

        assertEquals("", tree.convertValueToText(null, false, false, true, 0, false));

        assertEquals("any", tree.convertValueToText("any", false, false, true, 0, false));

        assertEquals("5", tree.convertValueToText(new Integer("5"), false, false, true, 0,

                false));

    }

    public void testCreateTreeModel() {

        Object obj1 = new Object[] { "node1", "node2", "node3" };

        Vector<String> obj2 = new Vector<String>();

        obj2.add("node1");

        obj2.add("node2");

        obj2.add("node3");

        Hashtable<String, String> obj3 = new Hashtable<String, String>();

        obj3.put("node1", "value1");

        obj3.put("node2", "value3");

        obj3.put("node3", "value3");

        Object obj4 = "object";

        List<String> obj5 = new ArrayList<String>();

        obj5.add("node1");

        obj5.add("node2");

        obj5.add("node3");

        Object obj6 = new int[] { 1, 2, 3 };

        Vector<Vector<String>> obj7 = new Vector<Vector<String>>();

        Vector<String> obj71 = new Vector<String>();

        obj71.add("node1");

        obj71.add("node2");

        obj7.add(obj71);

        TreeModel model = JTree.createTreeModel(obj1);

        assertTrue(model instanceof DefaultTreeModel);

        assertTrue(model.getRoot() instanceof DefaultMutableTreeNode);

        assertEquals("root", ((DefaultMutableTreeNode) model.getRoot()).getUserObject());

        assertEquals(3, model.getChildCount(model.getRoot()));

        assertTrue(model.getChild(model.getRoot(), 0) instanceof JTree.DynamicUtilTreeNode);

        model = JTree.createTreeModel(obj2);

        assertTrue(model instanceof DefaultTreeModel);

        assertTrue(model.getRoot() instanceof DefaultMutableTreeNode);

        assertEquals("root", ((DefaultMutableTreeNode) model.getRoot()).getUserObject());

        assertEquals(3, model.getChildCount(model.getRoot()));