java/testFramework/src/com/intellij/testFramework/codeInsight/hierarchy/HierarchyViewTestBase.java

   1 package com.intellij.testFramework.codeInsight.hierarchy;
   2
   3 import com.intellij.codeInsight.CodeInsightTestCase;
   4 import com.intellij.ide.hierarchy.HierarchyNodeDescriptor;
   5 import com.intellij.ide.hierarchy.HierarchyTreeStructure;
   6 import com.intellij.openapi.util.Computable;
   7 import com.intellij.openapi.util.JDOMUtil;
   8 import org.jdom.Document;
   9 import org.jdom.Element;
  10
  11 import java.io.File;
  12 import java.util.*;
  13
  14 /**
  15  * Checks tree structure for Type Hierarchy (Ctrl+H), Call Hierarchy (Ctrl+Alt+H), Method Hierarchy (Ctrl+Shift+H).
  16  */
  17 public abstract class HierarchyViewTestBase extends CodeInsightTestCase {
  18
  19   private static final String NODE_ELEMENT_NAME = "node";
  20   private static final String ANY_NODES_ELEMENT_NAME = "any";
  21   private static final String TEXT_ATTR_NAME = "text";
  22   private static final String BASE_ATTR_NAME = "base";
  23
  24   protected abstract String getBasePath();
  25
  26   protected void doHierarchyTest(final Computable<HierarchyTreeStructure> treeStructureComputable, final String... fileNames)
  27     throws Exception {
  28     final String[] relFilePaths = new String[fileNames.length];
  29     for (int i = 0; i < fileNames.length; i++) {
  30       relFilePaths[i] = "/" + getBasePath() + "/" + fileNames[i];
  31     }
  32     configureByFiles(null, relFilePaths);
  33
  34     final String verificationFilePath = getTestDataPath() + "/" + getBasePath() + "/" + getTestName(false) + "_verification.xml";
  35     checkHierarchyTreeStructure(treeStructureComputable.compute(), JDOMUtil.loadDocument(new File(verificationFilePath)));
  36   }
  37
  38   private static void checkHierarchyTreeStructure(final HierarchyTreeStructure treeStructure, final Document document) {
  39     final HierarchyNodeDescriptor rootNodeDescriptor = (HierarchyNodeDescriptor)treeStructure.getRootElement();
  40     rootNodeDescriptor.update();
  41     final Element rootElement = document.getRootElement();
  42     if (rootElement == null || !NODE_ELEMENT_NAME.equals(rootElement.getName())) {
  43       throw new IllegalArgumentException("Incorrect root element in verification resource");
  44     }
  45     checkNodeDescriptorRecursively(treeStructure, rootNodeDescriptor, rootElement);
  46   }
  47
  48   private static void checkNodeDescriptorRecursively(final HierarchyTreeStructure treeStructure,
  49                                                      final HierarchyNodeDescriptor descriptor,
  50                                                      final Element expectedElement) {
  51     checkBaseNode(treeStructure, descriptor, expectedElement);
  52     checkContent(descriptor, expectedElement);
  53     checkChildren(treeStructure, descriptor, expectedElement);
  54   }
  55
  56   private static void checkBaseNode(final HierarchyTreeStructure treeStructure,
  57                                     final HierarchyNodeDescriptor descriptor,
  58                                     final Element expectedElement) {
  59     final String baseAttrValue = expectedElement.getAttributeValue(BASE_ATTR_NAME);
  60     final HierarchyNodeDescriptor baseDescriptor = treeStructure.getBaseDescriptor();
  61     final boolean mustBeBase = "true".equalsIgnoreCase(baseAttrValue);
  62     assertTrue("Incorrect base node", mustBeBase ? baseDescriptor == descriptor : baseDescriptor != descriptor);
  63   }
  64
  65   private static void checkContent(final HierarchyNodeDescriptor descriptor, final Element expectedElement) {
  66     assertEquals(expectedElement.getAttributeValue(TEXT_ATTR_NAME), descriptor.getHighlightedText().getText());
  67   }
  68
  69   private static void checkChildren(final HierarchyTreeStructure treeStructure,
  70                                     final HierarchyNodeDescriptor descriptor,
  71                                     final Element element) {
  72     if (element.getChild(ANY_NODES_ELEMENT_NAME) != null) {
  73       return;
  74     }
  75
  76     final Object[] children = treeStructure.getChildElements(descriptor);
  77     //noinspection unchecked
  78     final List<Element> expectedChildren = new ArrayList<Element>(element.getChildren(NODE_ELEMENT_NAME));
  79
  80     final StringBuilder messageBuilder = new StringBuilder("Actual children of [" + descriptor.getHighlightedText().getText() + "]:\n");
  81     for (Object child : children) {
  82       final HierarchyNodeDescriptor nodeDescriptor = (HierarchyNodeDescriptor)child;
  83       nodeDescriptor.update();
  84       messageBuilder.append("    [").append(nodeDescriptor.getHighlightedText().getText()).append("]\n");
  85     }
  86     assertEquals(messageBuilder.toString(), expectedChildren.size(), children.length);
  87
  88     Arrays.sort(children, new Comparator<Object>() {
  89       public int compare(final Object first, final Object second) {
  90         return ((HierarchyNodeDescriptor)first).getHighlightedText().getText()
  91           .compareTo(((HierarchyNodeDescriptor)second).getHighlightedText().getText());
  92       }
  93     });
  94
  95     Collections.sort(expectedChildren, new Comparator<Element>() {
  96       public int compare(final Element first, final Element second) {
  97         return first.getAttributeValue(TEXT_ATTR_NAME).compareTo(second.getAttributeValue(TEXT_ATTR_NAME));
  98       }
  99     });
 100
 101     //noinspection unchecked
 102     final Iterator<Element> iterator = expectedChildren.iterator();
 103     for (Object child : children) {
 104       checkNodeDescriptorRecursively(treeStructure, ((HierarchyNodeDescriptor)child), iterator.next());
 105     }
 106   }
 107
 108 }