TreeExpandCollapseTest.java

/*
 * Copyright 2000-2009 JetBrains s.r.o.
 *
 * Licensed 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.
 */
package com.intellij.ui;

import com.intellij.util.ui.tree.TreeUtil;
import junit.framework.TestCase;

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

public class TreeExpandCollapseTest extends TestCase {
  private final DefaultMutableTreeNode myRoot = new DefaultMutableTreeNode();
  private final DefaultTreeModel myTreeModel = new DefaultTreeModel(myRoot);
  private JTree myTree = new JTree(myTreeModel);
  private final DefaultMutableTreeNode myChildA = new DefaultMutableTreeNode();
  private final DefaultMutableTreeNode myChild2 = new DefaultMutableTreeNode();
  private TreePath myChildAPath;
  private TreePath myChild2Path;
  private final DefaultMutableTreeNode myChildB = new DefaultMutableTreeNode();
  private TreePath myChildBPath;

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    myTreeModel.insertNodeInto(myChildA, myRoot, 0);
    myTreeModel.insertNodeInto(myChildB, myRoot, 1);
    myTreeModel.insertNodeInto(myChild2, myChildA, 0);
    myTreeModel.insertNodeInto(new DefaultMutableTreeNode(), myChild2, 0);
    myTreeModel.insertNodeInto(new DefaultMutableTreeNode(), myChildB, 0);
    myChildAPath = TreeUtil.getPathFromRoot(myChildA);
    myChild2Path = TreeUtil.getPathFromRoot(myChild2);
    myChildBPath = TreeUtil.getPathFromRoot(myChildB);
  }

  public void testCollapse() {
    myTree.expandPath(myChildAPath);
    myTree.expandPath(myChild2Path);
    checkExpanded(myChild2Path);
    myTree.setSelectionPath(myChild2Path);
    TreeExpandCollapse.collapse(myTree);
    checkCollapsed(myChild2Path);
    checkExpanded(myChildAPath);
  }

  public void testCollapseWithoutSelection() {
    myTree.clearSelection();
    TreeExpandCollapse.collapse(myTree);
  }

  public void testExpandWithoutSelection() {
    myTree.clearSelection();
    TreeExpandCollapse.expand(myTree);
  }

  public void testExpand() {
    TreePath rootPath = collapseRoot();
    myTree.setSelectionPath(rootPath);
    TreeExpandCollapse.expand(myTree);
    checkExpanded(rootPath);
    checkCollapsed(myChildAPath);
  }

  public void testTotalFiniteExpand() {
    TreePath rootPath = collapseRoot();
    myTree.setSelectionPath(rootPath);
    TreeExpandCollapse.expandAll(myTree);
    checkExpanded(rootPath);
    checkExpanded(myChildAPath);
    checkExpanded(myChild2Path);
  }

  public void testInfiniteExpand() {
    InfiniteTreeModel model = new InfiniteTreeModel();
    myTree = new JTree(model);
    TreePath rootPath = new TreePath(model.getRoot());
    myTree.setSelectionPath(rootPath);
    myTree.collapsePath(rootPath);
    TreeExpandCollapse.expandAll(myTree);
    checkExpanded(rootPath);
    TreeExpandCollapse.expandAll(myTree);
  }

  public void testSubsequentExpand() {
    InfiniteTreeModel model = new InfiniteTreeModel();
    myTree = new JTree(model);
    TreeExpandCollapse.expandAll(myTree);
    TreePath path = new TreePath(model.getRoot());
    while (myTree.isExpanded(path)) path = path.pathByAddingChild(model.getChild(path.getLastPathComponent(), 0));
    checkCollapsed(path);
    TreeExpandCollapse.expandAll(myTree);
    checkExpanded(path);
  }

  public void testTotalExpandWithoutSelection() {
    collapseRoot();
    myTree.clearSelection();
    TreeExpandCollapse.expand(myTree);
    checkCollapsed(new TreePath(myRoot));
    checkCollapsed(myChildAPath);
    checkCollapsed(myChildBPath);
  }

  public void testTotalExpandWithSelection() {
    myTree.expandPath(new TreePath(myRoot));
    myTree.collapsePath(myChildAPath);
    myTree.collapsePath(myChildBPath);
    myTree.setSelectionPath(myChildAPath);
    TreeExpandCollapse.expandAll(myTree);
    checkExpanded(myChildAPath);
    checkCollapsed(myChildBPath);
  }

  public void testExpandAllWithManyLeafs() {
    collapseRoot();
    addChildren(500, myChild2);
    addChildren(500, myChildA);
    addChildren(500, myChildB);
    myTree.setSelectionPath(new TreePath(myRoot));
    TreeExpandCollapse.expandAll(myTree);
    checkExpanded(new TreePath(myRoot));
    checkExpanded(myChildAPath);
    checkExpanded(myChildBPath);
    checkExpanded(myChild2Path);
  }

  public void testExpandManyNotLeafs() {
    collapseRoot();
    TreePath[] treePaths = new TreePath[20];
    for (int i = 0; i < treePaths.length; i++) {
      DefaultMutableTreeNode child = new DefaultMutableTreeNode();
      myTreeModel.insertNodeInto(child, myChild2, 0);
      addChildren(20, child);
      treePaths[i] = myChild2Path.pathByAddingChild(child);
    }
    TreeExpandCollapse.expandAll(myTree);
    for (int i = 0; i < treePaths.length; i++) {
      TreePath treePath = treePaths[i];
      checkExpanded(treePath);
    }
  }

  private void addChildren(int childCount, DefaultMutableTreeNode node) {
    for (int i = 0; i < childCount; i++) {
      myTreeModel.insertNodeInto(new DefaultMutableTreeNode(), node, 0);
    }
  }

  private TreePath collapseRoot() {
    TreePath rootPath = new TreePath(myRoot);
    myTree.collapsePath(rootPath);
    myTree.setSelectionPath(rootPath);
    checkCollapsed(rootPath);
    return rootPath;
  }

  private void checkCollapsed(TreePath path) {
    assertFalse(myTree.isExpanded(path));
  }

  private void checkExpanded(TreePath path) {
    assertTrue(myTree.isExpanded(path));
  }

  static class InfiniteTreeModel extends BasicTreeModel {
    @Override
    public Object getRoot() {return new Integer(1); }

    @Override
    public Object getChild(Object parent, int index) {
      return new Integer(intValueOf(parent) + index + 1);
    }

    private int intValueOf(Object parent) {
      Integer i = (Integer) parent;
      int intValue = i.intValue();
      return intValue;
    }

    @Override
    public int getChildCount(Object parent) {return Math.min(3, intValueOf(parent)); }

    @Override
    public int getIndexOfChild(Object parent, Object child) {return intValueOf(child) - intValueOf(parent) - 1; }
  }
}