move to java-tests

2026-09-27 10:03:11 +07:00 · 2018-10-16 18:18:23 +03:00
parent 1b6afc1ea8
commit f19c53f88c
3 changed files with 248 additions and 0 deletions
@@ -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<PsiAnonymousClass> getAllAnonymous() {
+    JBTreeTraverser<AbstractTreeNode> 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<AbstractTreeNode> 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<Object[]> 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;
+  }
+}
@@ -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");
+    });
+  }
+}
@@ -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();
+    }
+  }
+}