From f19c53f88c319413adcb06102797acbbab94f26a Mon Sep 17 00:00:00 2001 From: Sergey Ignatov Date: Tue, 16 Oct 2018 18:16:39 +0300 Subject: [PATCH] move to java-tests --- ...vaAnonymousClassesInStructureViewTest.java | 106 ++++++++++++++++ .../intellij/projectView/RecursiveTest.java | 22 ++++ .../intellij/projectView/TreeBuilderTest.java | 120 ++++++++++++++++++ 3 files changed, 248 insertions(+) create mode 100644 java/java-tests/testSrc/com/intellij/projectView/JavaAnonymousClassesInStructureViewTest.java create mode 100644 java/java-tests/testSrc/com/intellij/projectView/RecursiveTest.java create mode 100644 java/java-tests/testSrc/com/intellij/projectView/TreeBuilderTest.java diff --git a/java/java-tests/testSrc/com/intellij/projectView/JavaAnonymousClassesInStructureViewTest.java b/java/java-tests/testSrc/com/intellij/projectView/JavaAnonymousClassesInStructureViewTest.java new file mode 100644 index 000000000000..139690ace0d3 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/projectView/JavaAnonymousClassesInStructureViewTest.java @@ -0,0 +1,106 @@ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.projectView; + +import com.intellij.ide.structureView.impl.java.FieldsFilter; +import com.intellij.ide.structureView.impl.java.JavaAnonymousClassesNodeProvider; +import com.intellij.ide.structureView.newStructureView.StructureViewComponent; +import com.intellij.ide.util.treeView.AbstractTreeNode; +import com.intellij.ide.util.treeView.smartTree.TreeElementWrapper; +import com.intellij.openapi.util.Ref; +import com.intellij.psi.PsiAnonymousClass; +import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; +import com.intellij.util.containers.JBIterable; +import com.intellij.util.containers.JBTreeTraverser; +import com.intellij.util.ui.tree.TreeUtil; +import org.intellij.lang.annotations.Language; +import org.jetbrains.annotations.NotNull; + +import javax.swing.tree.TreeModel; +import java.util.Collection; +import java.util.List; + +public class JavaAnonymousClassesInStructureViewTest extends LightCodeInsightFixtureTestCase { + @Language("JAVA") + private static final String CLASS_WITH_ANONYMOUS = "class Foo {\n" + + " Object field;\n" + + " Object o1 = new Object(){};\n" + + " Object o2 = new Object(){};\n" + + " Object o3 = new Object(){};\n" + + " Object o4 = new Object(){};\n" + + " Object o5 = new Object(){};\n" + + " Object o6 = new Object(){};\n" + + " Object o7 = new Object(){};\n" + + " Object o8 = new Object(){};\n" + + " Object o9 = new Object(){};\n" + + " Object o10 = new Object(){};\n" + + " Object o11 = new Object(){};\n" + + " Object o12 = new Object(){};\n" + + " Object o13 = new Object(){\n" + + " int num = 1;\n" + + " Object o1 = new Object(){};\n" + + " Object o2 = new Object(){};\n" + + " }; \n" + + "}"; + private static final int ANNO_FIELD_COUNT = 13; + private static final int FIELD_COUNT = 1; + + public void testAnonymousNotShown() { + assertEquals(getFieldsCount(), getElements(false, true).length); + } + + public void testAnonymousShown() { + final Object[] elements = getElements(); + assertEquals(getFieldsCount(), elements.length); + assertEquals(ANNO_FIELD_COUNT + 2, getAllAnonymous().size()); + } + + private List getAllAnonymous() { + JBTreeTraverser traverser = JBTreeTraverser.from(AbstractTreeNode::getChildren); + return traverser.withRoots(JBIterable.of(getElements()).filter(AbstractTreeNode.class)) + .traverse() + .map(StructureViewComponent::unwrapValue) + .filter(PsiAnonymousClass.class) + .toList(); + } + + public void testSorting() { + int i = 0; + for (Object element : getElements(true, false)) { + assertEquals("$" + ++i, element.toString()); + } + } + + public void testAnonymousInsideAnonymous() { + Object[] elements = getElements(); + TreeElementWrapper last = (TreeElementWrapper)elements[elements.length - 1]; + Collection children = last.getChildren(); + assertEquals(1, children.size()); + assertEquals(3, ((AbstractTreeNode)((List)children).get(0)).getChildren().size()); + } + + private Object[] getElements() { + return getElements(true, true); + } + + private Object[] getElements(boolean showAnonymous, boolean showFields) { + myFixture.configureByText("Foo.java", CLASS_WITH_ANONYMOUS); + Ref ref = Ref.create(); + myFixture.testStructureView(svc -> { + svc.setActionActive(JavaAnonymousClassesNodeProvider.ID, showAnonymous); + svc.setActionActive(FieldsFilter.ID, !showFields); + ref.set(getElements(svc)); + }); + return ref.get(); + } + + @NotNull + private static Object[] getElements(@NotNull StructureViewComponent svc) { + TreeModel model = svc.getTree().getModel(); + Object first = TreeUtil.getFirstNodePath(svc.getTree()).getLastPathComponent(); + return TreeUtil.nodeChildren(first, model).map(TreeUtil::getUserObject).toList().toArray(); + } + + private static int getFieldsCount() { + return ANNO_FIELD_COUNT + FIELD_COUNT; + } +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/projectView/RecursiveTest.java b/java/java-tests/testSrc/com/intellij/projectView/RecursiveTest.java new file mode 100644 index 000000000000..b1876a34cae3 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/projectView/RecursiveTest.java @@ -0,0 +1,22 @@ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.projectView; + +import com.intellij.ide.util.InheritedMembersNodeProvider; +import com.intellij.testFramework.PlatformTestUtil; +import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; + +public class RecursiveTest extends LightCodeInsightFixtureTestCase { + public void test() { + myFixture.configureByText("I.java", "interface I {" + + " class Impl implements I {" + + " }" + + "};"); + myFixture.testStructureView(component -> { + component.setActionActive(InheritedMembersNodeProvider.ID, true); + PlatformTestUtil.assertTreeEqual(component.getTree(), + "-I.java\n" + + " -I\n" + + " +Impl"); + }); + } +} diff --git a/java/java-tests/testSrc/com/intellij/projectView/TreeBuilderTest.java b/java/java-tests/testSrc/com/intellij/projectView/TreeBuilderTest.java new file mode 100644 index 000000000000..4fc82c6cd098 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/projectView/TreeBuilderTest.java @@ -0,0 +1,120 @@ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.projectView; + +import com.intellij.ide.util.treeView.AbstractTreeBuilder; +import com.intellij.ide.util.treeView.AbstractTreeStructure; +import com.intellij.ide.util.treeView.IndexComparator; +import com.intellij.ide.util.treeView.NodeDescriptor; +import com.intellij.openapi.progress.ProgressIndicator; +import com.intellij.openapi.progress.util.StatusBarProgress; +import com.intellij.openapi.util.Disposer; +import com.intellij.testFramework.LightPlatformTestCase; +import org.jetbrains.annotations.NotNull; + +import javax.swing.*; +import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.DefaultTreeModel; + +public class TreeBuilderTest extends LightPlatformTestCase { + private static final Integer ROOT = new Integer(0); + private static final boolean IS_FINITE = false; + private AbstractTreeStructure myInfiniteTreeStructure = new AbstractTreeStructure() { + @NotNull + @Override + public Object getRootElement() { + return ROOT; + } + + @NotNull + @Override + public Object[] getChildElements(@NotNull Object element) { + int intValue = intValueOf(element); + if (IS_FINITE && intValue == 2) { + return new Object[]{}; + } + return new Object[]{new Integer(intValue + 1)}; + } + + @Override + public Object getParentElement(@NotNull Object element) { + return element == ROOT ? null : + new Integer(intValueOf(element) - 1); + } + + @Override + @NotNull + public NodeDescriptor createDescriptor(@NotNull final Object element, NodeDescriptor parentDescriptor) { + return new NodeDescriptor(null, parentDescriptor) { + @Override + public boolean update() { + return false; + } + + @Override + public Object getElement() { + return element; + } + }; + } + + @Override + public void commit() { + } + + @Override + public boolean hasSomethingToCommit() { + return false; + } + + private int intValueOf(Object element) { + return ((Integer)element).intValue(); + } + }; + + @Override + protected void tearDown() throws Exception { + myInfiniteTreeStructure = null; + super.tearDown(); + } + + public void test() { + MyAbstractTreeBuilder treeBuilder = new MyAbstractTreeBuilder(); + try { + treeBuilder.init(); + } + finally { + Disposer.dispose(treeBuilder); + } + } + + private class MyAbstractTreeBuilder extends AbstractTreeBuilder { + MyAbstractTreeBuilder() { + super(new JTree(), new DefaultTreeModel(new DefaultMutableTreeNode(ROOT)), myInfiniteTreeStructure, IndexComparator.INSTANCE); + } + + @Override + protected boolean isAlwaysShowPlus(NodeDescriptor nodeDescriptor) { + return false; + } + + @Override + protected boolean isAutoExpandNode(NodeDescriptor nodeDescriptor) { + return nodeDescriptor.getElement() == ROOT; + } + + @Override + protected boolean isSmartExpand() { + return false; + } + + public void init() { + initRootNode(); + } + + @Override + @NotNull + protected ProgressIndicator createProgressIndicator() { + return new StatusBarProgress(); + } + } +}