From 5bd61a10b6440f66195c463ec996a94521752e30 Mon Sep 17 00:00:00 2001 From: "Gregory.Shrago" Date: Thu, 5 Oct 2017 01:17:34 +0300 Subject: [PATCH] async structure view: tool window: tests --- .../projectView/JavaTreeStructureTest.java | 237 ++++++------ .../projectView/ProjectTreeBuilderTest.java | 125 ++++--- .../StructureViewUpdatingTest.java | 338 +++++++++--------- .../intellij/json/JsonStructureViewTest.java | 16 +- .../testFramework/PlatformTestUtil.java | 71 +++- .../impl/CodeInsightTestFixtureImpl.java | 1 + .../PluginDescriptorStructureTest.java | 7 +- .../java/decompiler/IdeaDecompilerTest.kt | 5 +- .../jetbrains/rest/RestStructureViewTest.java | 2 +- 9 files changed, 438 insertions(+), 364 deletions(-) diff --git a/java/java-tests/testSrc/com/intellij/projectView/JavaTreeStructureTest.java b/java/java-tests/testSrc/com/intellij/projectView/JavaTreeStructureTest.java index 5b5546d697f8..e67649562fda 100644 --- a/java/java-tests/testSrc/com/intellij/projectView/JavaTreeStructureTest.java +++ b/java/java-tests/testSrc/com/intellij/projectView/JavaTreeStructureTest.java @@ -14,7 +14,7 @@ import com.intellij.openapi.util.Disposer; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.JavaDirectoryService; import com.intellij.psi.PsiClass; -import com.intellij.testFramework.IdeaTestUtil; +import com.intellij.testFramework.PlatformTestUtil; import com.intellij.testFramework.TestSourceBasedTestCase; import javax.swing.*; @@ -26,156 +26,177 @@ public class JavaTreeStructureTest extends TestSourceBasedTestCase { } public void testJavaClassStructure() { - dotest(new CheckAction() { + doTest(new CheckAction() { @Override - public void testClassStructure(StructureViewComponent structureViewComponent) { - structureViewComponent.setActionActive(JavaInheritedMembersNodeProvider.ID, true); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), - "-Class1.java\n" + - " -Class1\n" + - " getValue(): int\n" + - " getClass(): Class\n" + - " hashCode(): int\n" + - " equals(Object): boolean\n" + - " clone(): Object\n" + - " toString(): String\n" + - " notify(): void\n" + - " notifyAll(): void\n" + - " wait(long): void\n" + - " wait(long, int): void\n" + - " wait(): void\n" + - " finalize(): void\n" + - " myField1: boolean\n" + - " myField2: boolean\n"); + public void testClassStructure(StructureViewComponent svc) { + svc.setActionActive(JavaInheritedMembersNodeProvider.ID, true); - structureViewComponent.setActionActive(JavaInheritedMembersNodeProvider.ID, false); - structureViewComponent.setActionActive(JavaInheritedMembersNodeProvider.ID, true); - structureViewComponent.setActionActive(JavaInheritedMembersNodeProvider.ID, false); + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class1.java\n" + + " -Class1\n" + + " getValue(): int\n" + + " getClass(): Class\n" + + " hashCode(): int\n" + + " equals(Object): boolean\n" + + " clone(): Object\n" + + " toString(): String\n" + + " notify(): void\n" + + " notifyAll(): void\n" + + " wait(long): void\n" + + " wait(long, int): void\n" + + " wait(): void\n" + + " finalize(): void\n" + + " myField1: boolean\n" + + " myField2: boolean\n"); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class1.java\n" + - " -Class1\n" + - " getValue(): int\n" + - " myField1: boolean\n" + - " myField2: boolean\n"); + svc.setActionActive(JavaInheritedMembersNodeProvider.ID, false); + svc.setActionActive(JavaInheritedMembersNodeProvider.ID, true); + svc.setActionActive(JavaInheritedMembersNodeProvider.ID, false); - structureViewComponent.setActionActive(PublicElementsFilter.ID, true); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class1.java\n" + - " -Class1\n" + - " getValue(): int\n" + - " myField1: boolean\n" + - " myField2: boolean\n"); + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class1.java\n" + + " -Class1\n" + + " getValue(): int\n" + + " myField1: boolean\n" + + " myField2: boolean\n"); - structureViewComponent.setActionActive(PublicElementsFilter.ID, false); + svc.setActionActive(PublicElementsFilter.ID, true); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class1.java\n" + - " -Class1\n" + - " getValue(): int\n" + - " myField1: boolean\n" + - " myField2: boolean\n"); + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class1.java\n" + + " -Class1\n" + + " getValue(): int\n" + + " myField1: boolean\n" + + " myField2: boolean\n"); + + svc.setActionActive(PublicElementsFilter.ID, false); + + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class1.java\n" + + " -Class1\n" + + " getValue(): int\n" + + " myField1: boolean\n" + + " myField2: boolean\n"); } }); } public void testShowClassMembers() { - dotest(new CheckAction() { + doTest(new CheckAction() { @Override - public void testClassStructure(StructureViewComponent structureViewComponent) { - structureViewComponent.setActionActive(JavaInheritedMembersNodeProvider.ID, true); - final JTree tree = structureViewComponent.getTree(); + public void testClassStructure(StructureViewComponent svc) { + svc.setActionActive(JavaInheritedMembersNodeProvider.ID, true); + + JTree tree = svc.getTree(); tree.collapseRow(2); - IdeaTestUtil.assertTreeEqual(tree, "-Class2.java\n" + - " -Class2\n" + - " +InnerClass1\n" + - " +InnerClass2\n" + - " getValue(): int\n" + - " getClass(): Class\n" + - " hashCode(): int\n" + - " equals(Object): boolean\n" + - " clone(): Object\n" + - " toString(): String\n" + - " notify(): void\n" + - " notifyAll(): void\n" + - " wait(long): void\n" + - " wait(long, int): void\n" + - " wait(): void\n" + - " finalize(): void\n" + - " myField1: boolean\n" + - " myField2: boolean\n" + - " myField3: boolean\n" + - " myField4: boolean\n"); + PlatformTestUtil.assertTreeEqual( + tree, + "-Class2.java\n" + + " -Class2\n" + + " +InnerClass1\n" + + " +InnerClass2\n" + + " getValue(): int\n" + + " getClass(): Class\n" + + " hashCode(): int\n" + + " equals(Object): boolean\n" + + " clone(): Object\n" + + " toString(): String\n" + + " notify(): void\n" + + " notifyAll(): void\n" + + " wait(long): void\n" + + " wait(long, int): void\n" + + " wait(): void\n" + + " finalize(): void\n" + + " myField1: boolean\n" + + " myField2: boolean\n" + + " myField3: boolean\n" + + " myField4: boolean\n"); - structureViewComponent.setActionActive(JavaInheritedMembersNodeProvider.ID, false); + svc.setActionActive(JavaInheritedMembersNodeProvider.ID, false); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class2.java\n" + - " -Class2\n" + - " +InnerClass1\n" + - " +InnerClass2\n" + - " getValue(): int\n" + - " myField1: boolean\n" + - " myField2: boolean\n" + - " myField3: boolean\n" + - " myField4: boolean\n"); + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class2.java\n" + + " -Class2\n" + + " +InnerClass1\n" + + " +InnerClass2\n" + + " getValue(): int\n" + + " myField1: boolean\n" + + " myField2: boolean\n" + + " myField3: boolean\n" + + " myField4: boolean\n"); } }); } public void testVisibilitySorter() { - dotest(new CheckAction() { + doTest(new CheckAction() { @Override - public void testClassStructure(StructureViewComponent structureViewComponent) { - structureViewComponent.setActionActive(JavaInheritedMembersNodeProvider.ID, false); + public void testClassStructure(StructureViewComponent svc) { + svc.setActionActive(JavaInheritedMembersNodeProvider.ID, false); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class2.java\n" + - " -Class2\n" + - " __myPrivateFiield: int\n" + - " _myProtectedField: int\n" + - " myPublicField: int\n"); + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class2.java\n" + + " -Class2\n" + + " __myPrivateFiield: int\n" + + " _myProtectedField: int\n" + + " myPublicField: int\n"); - structureViewComponent.setActionActive(VisibilitySorter.ID, true); + svc.setActionActive(VisibilitySorter.ID, true); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class2.java\n" + - " -Class2\n" + - " myPublicField: int\n" + - " _myProtectedField: int\n" + - " __myPrivateFiield: int\n"); + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class2.java\n" + + " -Class2\n" + + " myPublicField: int\n" + + " _myProtectedField: int\n" + + " __myPrivateFiield: int\n"); } }); } public void testMembersOrder() { - dotest(new CheckAction() { + doTest(new CheckAction() { @Override - public void testClassStructure(StructureViewComponent structureViewComponent) { - structureViewComponent.setActionActive(JavaInheritedMembersNodeProvider.ID, false); + public void testClassStructure(StructureViewComponent svc) { + svc.setActionActive(JavaInheritedMembersNodeProvider.ID, false); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class2.java\n" + - " -Class2\n" + - " Class2()\n" + - " af(): void\n" + - " zf(): void\n" + - " ab: int\n" + - " z: int\n" + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class2.java\n" + + " -Class2\n" + + " Class2()\n" + + " af(): void\n" + + " zf(): void\n" + + " ab: int\n" + + " z: int\n" ); } }); } + interface CheckAction { void testClassStructure(StructureViewComponent structureViewComponent); } - private void dotest(CheckAction checkAction) { - final PsiClass psiClass = JavaDirectoryService.getInstance().getClasses(getPackageDirectory("com/package1"))[0]; - final VirtualFile virtualFile = psiClass.getContainingFile().getVirtualFile(); - final FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); + + private void doTest(CheckAction checkAction) { + PsiClass psiClass = JavaDirectoryService.getInstance().getClasses(getPackageDirectory("com/package1"))[0]; + VirtualFile virtualFile = psiClass.getContainingFile().getVirtualFile(); + FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); FileEditor[] fileEditors = fileEditorManager.openFile(virtualFile, false); - final FileEditor fileEditor = fileEditors[0]; + FileEditor fileEditor = fileEditors[0]; try { - final StructureViewComponent structureViewComponent = + StructureViewComponent svc = (StructureViewComponent)fileEditor.getStructureViewBuilder().createStructureView(fileEditor, myProject); - checkAction.testClassStructure(structureViewComponent); - Disposer.dispose(structureViewComponent); - + checkAction.testClassStructure(svc); + Disposer.dispose(svc); } finally { fileEditorManager.closeFile(virtualFile); diff --git a/java/java-tests/testSrc/com/intellij/projectView/ProjectTreeBuilderTest.java b/java/java-tests/testSrc/com/intellij/projectView/ProjectTreeBuilderTest.java index 6b786db1fb7b..5d36cb46238f 100644 --- a/java/java-tests/testSrc/com/intellij/projectView/ProjectTreeBuilderTest.java +++ b/java/java-tests/testSrc/com/intellij/projectView/ProjectTreeBuilderTest.java @@ -11,12 +11,16 @@ import com.intellij.psi.JavaDirectoryService; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiField; import com.intellij.psi.PsiFile; -import com.intellij.testFramework.IdeaTestUtil; +import com.intellij.testFramework.PlatformTestUtil; import com.intellij.testFramework.ProjectViewTestUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.ui.tree.TreeUtil; +import org.jetbrains.concurrency.Promise; + +import javax.swing.tree.TreePath; public class ProjectTreeBuilderTest extends BaseProjectViewTestCase { + public void testStandardProviders() { getProjectTreeStructure().setProviders(); @@ -51,30 +55,30 @@ public class ProjectTreeBuilderTest extends BaseProjectViewTestCase { myStructure.checkNavigateFromSourceBehaviour(innerClass2Field, innerClass2Field.getContainingFile().getVirtualFile(), pane); - IdeaTestUtil.assertTreeEqual(pane.getTree(), "-Project\n" + - " -PsiDirectory: showClassMembers\n" + - " -PsiDirectory: src\n" + - " -PsiDirectory: com\n" + - " -PsiDirectory: package1\n" + - " +Class1\n" + - " -Class2\n" + - " +InnerClass1\n" + - " -InnerClass2\n" + - " -InnerClass22\n" + - " -InnerClass23\n" + - " -InnerClass24\n" + - " +InnerClass25\n" + - " myFieldToSelect:int\n" + - " myInnerClassField:int\n" + - " myInnerClassField:int\n" + - " myInnerClassField:int\n" + - " getValue():int\n" + - " myField1:boolean\n" + - " myField2:boolean\n" + - " myField3:boolean\n" + - " myField4:boolean\n" + - getRootFiles() + - " +External Libraries\n" + PlatformTestUtil.assertTreeEqual(pane.getTree(), "-Project\n" + + " -PsiDirectory: showClassMembers\n" + + " -PsiDirectory: src\n" + + " -PsiDirectory: com\n" + + " -PsiDirectory: package1\n" + + " +Class1\n" + + " -Class2\n" + + " +InnerClass1\n" + + " -InnerClass2\n" + + " -InnerClass22\n" + + " -InnerClass23\n" + + " -InnerClass24\n" + + " +InnerClass25\n" + + " myFieldToSelect:int\n" + + " myInnerClassField:int\n" + + " myInnerClassField:int\n" + + " myInnerClassField:int\n" + + " getValue():int\n" + + " myField1:boolean\n" + + " myField2:boolean\n" + + " myField3:boolean\n" + + " myField4:boolean\n" + + getRootFiles() + + " +External Libraries\n" ); assertFalse(ProjectViewTestUtil.isExpanded(innerClass15.getFields()[0], pane)); @@ -84,49 +88,40 @@ public class ProjectTreeBuilderTest extends BaseProjectViewTestCase { VirtualFile virtualFile = aClass.getContainingFile().getVirtualFile(); FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); FileEditor[] fileEditors = fileEditorManager.openFile(virtualFile, false); - StructureViewComponent structureViewComponent2 = null; - StructureViewComponent structureViewComponent = null; + StructureViewComponent svc = (StructureViewComponent)fileEditors[0].getStructureViewBuilder() + .createStructureView(fileEditors[0], myProject); + Disposer.register(getTestRootDisposable(), svc); + TreeUtil.collapseAll(svc.getTree(), -1); + fileEditorManager.closeFile(virtualFile); - try { - structureViewComponent = (StructureViewComponent)fileEditors[0].getStructureViewBuilder().createStructureView(fileEditors[0], myProject); - TreeUtil.collapseAll(structureViewComponent.getTree(), -1); + Promise select = svc.select(innerClass2Field, true); + PlatformTestUtil.waitForPromise(select); - structureViewComponent.select(innerClass2Field, true); + String expected = "-Class2.java\n" + + " -Class2\n" + + " +InnerClass1\n" + + " -InnerClass2\n" + + " -InnerClass22\n" + + " -InnerClass23\n" + + " -InnerClass24\n" + + " +InnerClass25\n" + + " myFieldToSelect: int\n" + + " myInnerClassField: int\n" + + " myInnerClassField: int\n" + + " myInnerClassField: int\n" + + " getValue(): int\n" + + " myField1: boolean\n" + + " myField2: boolean\n" + + " myField3: boolean\n" + + " myField4: boolean\n"; - String expected = "-Class2.java\n" + - " -Class2\n" + - " +InnerClass1\n" + - " -InnerClass2\n" + - " -InnerClass22\n" + - " -InnerClass23\n" + - " -InnerClass24\n" + - " +InnerClass25\n" + - " myFieldToSelect: int\n" + - " myInnerClassField: int\n" + - " myInnerClassField: int\n" + - " myInnerClassField: int\n" + - " getValue(): int\n" + - " myField1: boolean\n" + - " myField2: boolean\n" + - " myField3: boolean\n" + - " myField4: boolean\n"; + PlatformTestUtil.assertTreeEqual(svc.getTree(), expected); + Disposer.dispose(svc); - IdeaTestUtil.assertTreeEqual(structureViewComponent.getTree(), - expected); - - - Disposer.dispose(structureViewComponent); - - final FileEditor fileEditor = fileEditors[0]; - structureViewComponent2 = (StructureViewComponent)fileEditor.getStructureViewBuilder().createStructureView(fileEditor, myProject); - structureViewComponent2.setActionActive(JavaInheritedMembersNodeProvider.ID, false); - IdeaTestUtil.assertTreeEqual(structureViewComponent2.getTree(), expected); - } - finally { - fileEditorManager.closeFile(virtualFile); - if (structureViewComponent2 != null) { - Disposer.dispose(structureViewComponent2); - } - } + FileEditor fileEditor = fileEditors[0]; + StructureViewComponent svc2 = (StructureViewComponent)fileEditor.getStructureViewBuilder().createStructureView(fileEditor, myProject); + Disposer.register(getTestRootDisposable(), svc2); + svc2.setActionActive(JavaInheritedMembersNodeProvider.ID, false); + PlatformTestUtil.assertTreeEqual(svc2.getTree(), expected); } } diff --git a/java/java-tests/testSrc/com/intellij/projectView/StructureViewUpdatingTest.java b/java/java-tests/testSrc/com/intellij/projectView/StructureViewUpdatingTest.java index 7a783bbb39c8..b4290e02e227 100644 --- a/java/java-tests/testSrc/com/intellij/projectView/StructureViewUpdatingTest.java +++ b/java/java-tests/testSrc/com/intellij/projectView/StructureViewUpdatingTest.java @@ -36,186 +36,178 @@ import com.intellij.util.IncorrectOperationException; import javax.swing.*; public class StructureViewUpdatingTest extends TestSourceBasedTestCase { + @Override protected String getTestPath() { return "structureView"; } - public void testJavaClassStructure() { - final PsiClass psiClass = JavaDirectoryService.getInstance().getClasses(getPackageDirectory("com/package1"))[0]; - final VirtualFile virtualFile = psiClass.getContainingFile().getVirtualFile(); - final FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); - FileEditor[] fileEditors = fileEditorManager.openFile(virtualFile, false); - final FileEditor fileEditor = fileEditors[0]; - try { - final StructureViewComponent structureViewComponent = - (StructureViewComponent)fileEditor.getStructureViewBuilder().createStructureView(fileEditor, myProject); - final Document document = PsiDocumentManager.getInstance(myProject).getDocument(psiClass.getContainingFile()); - structureViewComponent.setActionActive(InheritedMembersNodeProvider.ID, true); - PlatformTestUtil.assertTreeEqual(structureViewComponent.getTree(), - "-Class1.java\n" + - " -Class1\n" + - " getValue(): int\n" + - " getClass(): Class\n" + - " hashCode(): int\n" + - " equals(Object): boolean\n" + - " clone(): Object\n" + - " toString(): String\n" + - " notify(): void\n" + - " notifyAll(): void\n" + - " wait(long): void\n" + - " wait(long, int): void\n" + - " wait(): void\n" + - " finalize(): void\n" + - " myField1: boolean\n" + - " myField2: boolean\n"); - - new WriteCommandAction.Simple(getProject()) { - @Override - protected void run() { - final int offset = document.getLineStartOffset(5); - document.insertString(offset, " boolean myNewField = false;\n"); - } - }.execute().throwException(); - - - PsiDocumentManager.getInstance(myProject).commitDocument(document); - - PlatformTestUtil.waitForAlarm(600); - - //TreeUtil.expand(structureViewComponent.getTree(), 3); - - PlatformTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class1.java\n" + - " -Class1\n" + " getValue(): int\n" + - " getClass(): Class\n" + - " hashCode(): int\n" + - " equals(Object): boolean\n" + - " clone(): Object\n" + - " toString(): String\n" + - " notify(): void\n" + - " notifyAll(): void\n" + - " wait(long): void\n" + - " wait(long, int): void\n" + - " wait(): void\n" + - " finalize(): void\n" + - " myField1: boolean\n" + - " myField2: boolean\n" + - " myNewField: boolean = false\n"); - - Disposer.dispose(structureViewComponent); - - } - finally { - fileEditorManager.closeFile(virtualFile); - } - } - - public void testShowClassMembers() { - final PsiClass psiClass = JavaDirectoryService.getInstance().getClasses(getPackageDirectory("com/package1"))[0]; - final VirtualFile virtualFile = psiClass.getContainingFile().getVirtualFile(); - final FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); - FileEditor[] fileEditors = fileEditorManager.openFile(virtualFile, false); - final FileEditor fileEditor = fileEditors[0]; - final StructureViewComponent structureViewComponent = - (StructureViewComponent)fileEditor.getStructureViewBuilder().createStructureView(fileEditor, myProject); - try { - PlatformTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class2.java\n" + - " -Class2\n" + - " +InnerClass1\n" + - " +InnerClass2\n" + - " getValue(): int\n" + - " myField1: boolean\n" + - " myField2: boolean\n" + - " myField3: boolean\n" + - " myField4: boolean\n"); - - final PsiField innerClassField = psiClass.getInnerClasses()[0].getFields()[0]; - - structureViewComponent.select(innerClassField, true); - - PlatformTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class2.java\n" + - " -Class2\n" + - " -InnerClass1\n" + - " +InnerClass12\n" + - " myInnerClassField: int\n" + - " +InnerClass2\n" + - " getValue(): int\n" + - " myField1: boolean\n" + - " myField2: boolean\n" + - " myField3: boolean\n" + - " myField4: boolean\n"); - - CommandProcessor.getInstance().executeCommand(myProject, () -> WriteCommandAction.runWriteCommandAction(null, () -> { - try { - innerClassField.delete(); - } - catch (IncorrectOperationException e) { - fail(e.getLocalizedMessage()); - } - }), null, null); - - PlatformTestUtil.waitForAlarm(600); - - PlatformTestUtil.assertTreeEqual(structureViewComponent.getTree(), "-Class2.java\n" + - " -Class2\n" + - " -InnerClass1\n" + - " +InnerClass12\n" + - " +InnerClass2\n" + - " getValue(): int\n" + - " myField1: boolean\n" + - " myField2: boolean\n" + - " myField3: boolean\n" + - " myField4: boolean\n"); - - } - finally { - Disposer.dispose(structureViewComponent); - fileEditorManager.closeFile(virtualFile); - } - } - - public void testExpandElementWithExitingName() { - - final VirtualFile xmlVirtualFile = getContentRoot().findFileByRelativePath("test.xml"); - final FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); - FileEditor[] fileEditors = fileEditorManager.openFile(xmlVirtualFile, false); - final FileEditor fileEditor = fileEditors[0]; - try { - final StructureViewComponent structureViewComponent = - (StructureViewComponent)fileEditor.getStructureViewBuilder().createStructureView(fileEditor, myProject); - - final JTree tree = structureViewComponent.getTree(); - PlatformTestUtil.assertTreeEqual(tree, "-test.xml\n" + - " -test\n" + - " +level1\n" + - " +level1\n" + - " +level1\n" + - " +level1\n"); - - tree.expandPath(tree.getPathForRow(3)); - - PlatformTestUtil.waitForAlarm(600); - - - PlatformTestUtil.assertTreeEqual(tree, - "-test.xml\n" + - " -test\n" + - " +level1\n" + - " -level1\n" + - " +level2\n" + - " +level1\n" + - " +level1\n"); - - Disposer.dispose(structureViewComponent); - } - finally { - fileEditorManager.closeFile(xmlVirtualFile); - } - - } - @Override protected String getTestDataPath() { return JavaTestUtil.getJavaTestDataPath(); } + + public void testJavaClassStructure() { + PsiClass psiClass = JavaDirectoryService.getInstance().getClasses(getPackageDirectory("com/package1"))[0]; + VirtualFile virtualFile = psiClass.getContainingFile().getVirtualFile(); + FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); + FileEditor[] fileEditors = fileEditorManager.openFile(virtualFile, false); + FileEditor fileEditor = fileEditors[0]; + StructureViewComponent svc = (StructureViewComponent)fileEditor.getStructureViewBuilder() + .createStructureView(fileEditor, myProject); + Disposer.register(getTestRootDisposable(), svc); + fileEditorManager.closeFile(virtualFile); + Document document = PsiDocumentManager.getInstance(myProject).getDocument(psiClass.getContainingFile()); + svc.setActionActive(InheritedMembersNodeProvider.ID, true); + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class1.java\n" + + " -Class1\n" + + " getValue(): int\n" + + " getClass(): Class\n" + + " hashCode(): int\n" + + " equals(Object): boolean\n" + + " clone(): Object\n" + + " toString(): String\n" + + " notify(): void\n" + + " notifyAll(): void\n" + + " wait(long): void\n" + + " wait(long, int): void\n" + + " wait(): void\n" + + " finalize(): void\n" + + " myField1: boolean\n" + + " myField2: boolean\n"); + + new WriteCommandAction.Simple(getProject()) { + @Override + protected void run() { + int offset = document.getLineStartOffset(5); + document.insertString(offset, " boolean myNewField = false;\n"); + } + }.execute().throwException(); + + PsiDocumentManager.getInstance(myProject).commitDocument(document); + + PlatformTestUtil.waitForAlarm(600); + + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class1.java\n" + + " -Class1\n" + " getValue(): int\n" + + " getClass(): Class\n" + + " hashCode(): int\n" + + " equals(Object): boolean\n" + + " clone(): Object\n" + + " toString(): String\n" + + " notify(): void\n" + + " notifyAll(): void\n" + + " wait(long): void\n" + + " wait(long, int): void\n" + + " wait(): void\n" + + " finalize(): void\n" + + " myField1: boolean\n" + + " myField2: boolean\n" + + " myNewField: boolean = false\n"); + } + + public void testShowClassMembers() { + PsiClass psiClass = JavaDirectoryService.getInstance().getClasses(getPackageDirectory("com/package1"))[0]; + VirtualFile virtualFile = psiClass.getContainingFile().getVirtualFile(); + FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); + FileEditor[] fileEditors = fileEditorManager.openFile(virtualFile, false); + FileEditor fileEditor = fileEditors[0]; + StructureViewComponent svc = (StructureViewComponent)fileEditor.getStructureViewBuilder() + .createStructureView(fileEditor, myProject); + Disposer.register(getTestRootDisposable(), svc); + fileEditorManager.closeFile(virtualFile); + PlatformTestUtil.waitForPromise(svc.rebuildAndUpdate()); + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class2.java\n" + + " -Class2\n" + + " +InnerClass1\n" + + " +InnerClass2\n" + + " getValue(): int\n" + + " myField1: boolean\n" + + " myField2: boolean\n" + + " myField3: boolean\n" + + " myField4: boolean\n"); + + PsiField innerClassField = psiClass.getInnerClasses()[0].getFields()[0]; + + svc.select(innerClassField, true); + + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class2.java\n" + + " -Class2\n" + + " -InnerClass1\n" + + " +InnerClass12\n" + + " myInnerClassField: int\n" + + " +InnerClass2\n" + + " getValue(): int\n" + + " myField1: boolean\n" + + " myField2: boolean\n" + + " myField3: boolean\n" + + " myField4: boolean\n"); + + CommandProcessor.getInstance().executeCommand(myProject, () -> WriteCommandAction.runWriteCommandAction(null, () -> { + try { + innerClassField.delete(); + } + catch (IncorrectOperationException e) { + fail(e.getLocalizedMessage()); + } + }), null, null); + + PlatformTestUtil.waitForAlarm(1000); + + PlatformTestUtil.assertTreeEqual( + svc.getTree(), + "-Class2.java\n" + + " -Class2\n" + + " -InnerClass1\n" + + " +InnerClass12\n" + + " +InnerClass2\n" + + " getValue(): int\n" + + " myField1: boolean\n" + + " myField2: boolean\n" + + " myField3: boolean\n" + + " myField4: boolean\n"); + } + + public void testExpandElementWithExitingName() { + + VirtualFile xmlVirtualFile = getContentRoot().findFileByRelativePath("test.xml"); + FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject); + FileEditor[] fileEditors = fileEditorManager.openFile(xmlVirtualFile, false); + FileEditor fileEditor = fileEditors[0]; + StructureViewComponent svc = (StructureViewComponent)fileEditor.getStructureViewBuilder() + .createStructureView(fileEditor, myProject); + Disposer.register(getTestRootDisposable(), svc); + fileEditorManager.closeFile(xmlVirtualFile); + PlatformTestUtil.waitForPromise(svc.rebuildAndUpdate()); + + JTree tree = svc.getTree(); + PlatformTestUtil.assertTreeEqual( + tree, + "-test.xml\n" + + " -test\n" + + " +level1\n" + + " +level1\n" + + " +level1\n" + + " +level1\n"); + + tree.expandPath(tree.getPathForRow(3)); + + PlatformTestUtil.assertTreeEqual( + tree, + "-test.xml\n" + + " -test\n" + + " +level1\n" + + " -level1\n" + + " +level2\n" + + " +level1\n" + + " +level1\n"); + } } diff --git a/json/tests/test/com/intellij/json/JsonStructureViewTest.java b/json/tests/test/com/intellij/json/JsonStructureViewTest.java index e05c32ec9a10..56f241cf3ec2 100644 --- a/json/tests/test/com/intellij/json/JsonStructureViewTest.java +++ b/json/tests/test/com/intellij/json/JsonStructureViewTest.java @@ -23,7 +23,7 @@ public class JsonStructureViewTest extends JsonTestCase { private void doTest(final String expected) { myFixture.configureByFile(getTestName(false) + ".json"); - myFixture.testStructureView(component -> assertTreeEqual(component.getTree(), expected)); + myFixture.testStructureView(svc -> assertTreeEqual(svc.getTree(), expected)); } private void doTestTreeStructure(@NotNull Consumer consumer) { @@ -65,14 +65,24 @@ public class JsonStructureViewTest extends JsonTestCase { " -node2\n" + " -object\n" + " -subNode2\n" + - " +object\n" + + " -object\n" + + " someNode\n" + " -node3\n" + " -object\n" + " prop1\n" + " prop2\n" + " someFlag\n" + " -array\n" + - " +object\n"); + " -object\n" + + " arrProp1\n" + + " -array2\n" + + " -object\n" + + " arr2Prop1\n" + + " arr2Prop2\n" + + " -array3\n" + + " -object\n" + + " prop1\n" + + " prop2\n"); } // IDEA-131502 diff --git a/platform/testFramework/src/com/intellij/testFramework/PlatformTestUtil.java b/platform/testFramework/src/com/intellij/testFramework/PlatformTestUtil.java index 88650667ea05..4f46000c2ed0 100644 --- a/platform/testFramework/src/com/intellij/testFramework/PlatformTestUtil.java +++ b/platform/testFramework/src/com/intellij/testFramework/PlatformTestUtil.java @@ -26,6 +26,7 @@ import com.intellij.ide.fileTemplates.FileTemplateManager; import com.intellij.ide.fileTemplates.impl.FileTemplateManagerImpl; import com.intellij.ide.util.treeView.AbstractTreeNode; import com.intellij.ide.util.treeView.AbstractTreeStructure; +import com.intellij.ide.util.treeView.NodeDescriptor; import com.intellij.idea.Bombed; import com.intellij.openapi.Disposable; import com.intellij.openapi.actionSystem.*; @@ -66,15 +67,18 @@ import com.intellij.util.containers.HashMap; import com.intellij.util.io.ZipUtil; import com.intellij.util.ref.GCUtil; import com.intellij.util.ui.UIUtil; +import com.intellij.util.ui.tree.TreeUtil; import gnu.trove.Equality; import junit.framework.AssertionFailedError; import org.jdom.Element; import org.jdom.JDOMException; import org.jetbrains.annotations.*; +import org.jetbrains.concurrency.Promise; import org.junit.Assert; import javax.swing.*; import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.TreeModel; import javax.swing.tree.TreePath; import java.awt.*; import java.awt.event.InvocationEvent; @@ -86,6 +90,7 @@ import java.nio.charset.Charset; import java.util.*; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Function; import java.util.jar.JarFile; @@ -243,6 +248,28 @@ public class PlatformTestUtil { Assert.assertEquals(expected, treeStringPresentation); } + @TestOnly + public static void waitForPromise(@NotNull Promise promise) { + Application app = ApplicationManager.getApplication(); + assert !app.isWriteAccessAllowed() : "It's a bad idea to wait for a promise under the write action. Somebody creates an alarm which requires read action and you are deadlocked."; + assert app.isDispatchThread(); + AtomicBoolean complete = new AtomicBoolean(false); + promise.processed(ignore -> complete.set(true)); + long start = System.currentTimeMillis(); + while (!complete.get()) { + UIUtil.dispatchAllInvocationEvents(); + try { + promise.blockingGet(20, TimeUnit.MILLISECONDS); + } + catch (Exception ignore) { + } + if (System.currentTimeMillis() - start > 100 * 1000) { + throw new AssertionError("The promise takes too long... aborting"); + } + } + UIUtil.dispatchAllInvocationEvents(); + } + @TestOnly public static void waitForAlarm(final int delay) { Application app = ApplicationManager.getApplication(); @@ -437,15 +464,45 @@ public class PlatformTestUtil { return print(tree, false); } - public static void updateRecursively(@NotNull AbstractTreeNode node) { - node.update(); - for (AbstractTreeNode child : node.getChildren()) { - updateRecursively(child); - } + public static void assertTreeStructureEquals(@NotNull TreeModel treeModel, @NotNull String expected) { + Assert.assertEquals(expected.trim(), print(createStructure(treeModel), treeModel.getRoot(), 0, null, -1, ' ', (Queryable.PrintInfo)null).toString().trim()); } - public static void assertTreeStructureEquals(@NotNull AbstractTreeStructure treeStructure, @NotNull String expected) { - Assert.assertEquals(expected.trim(), print(treeStructure, treeStructure.getRootElement(), 0, null, -1, ' ', (Queryable.PrintInfo)null).toString().trim()); + @NotNull + protected static AbstractTreeStructure createStructure(@NotNull TreeModel treeModel) { + return new AbstractTreeStructure() { + @Override + public Object getRootElement() { + return treeModel.getRoot(); + } + + @Override + public Object[] getChildElements(Object element) { + return TreeUtil.nodeChildren(element, treeModel).toList().toArray(); + } + + @Nullable + @Override + public Object getParentElement(Object element) { + return ((AbstractTreeNode)element).getParent(); + } + + @NotNull + @Override + public NodeDescriptor createDescriptor(Object element, NodeDescriptor parentDescriptor) { + throw new UnsupportedOperationException(); + } + + @Override + public void commit() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean hasSomethingToCommit() { + throw new UnsupportedOperationException(); + } + }; } public static void invokeNamedAction(final String actionId) { diff --git a/platform/testFramework/src/com/intellij/testFramework/fixtures/impl/CodeInsightTestFixtureImpl.java b/platform/testFramework/src/com/intellij/testFramework/fixtures/impl/CodeInsightTestFixtureImpl.java index 5d00531c1b87..90595a47fd30 100644 --- a/platform/testFramework/src/com/intellij/testFramework/fixtures/impl/CodeInsightTestFixtureImpl.java +++ b/platform/testFramework/src/com/intellij/testFramework/fixtures/impl/CodeInsightTestFixtureImpl.java @@ -1815,6 +1815,7 @@ public class CodeInsightTestFixtureImpl extends BaseFixture implements CodeInsig StructureViewComponent component = null; try { component = (StructureViewComponent)builder.createStructureView(fileEditor, getProject()); + PlatformTestUtil.waitForPromise(component.rebuildAndUpdate()); consumer.consume(component); } finally { diff --git a/plugins/devkit/testSources/navigation/structure/PluginDescriptorStructureTest.java b/plugins/devkit/testSources/navigation/structure/PluginDescriptorStructureTest.java index caa03a225118..3d71d0b6b2d8 100644 --- a/plugins/devkit/testSources/navigation/structure/PluginDescriptorStructureTest.java +++ b/plugins/devkit/testSources/navigation/structure/PluginDescriptorStructureTest.java @@ -4,8 +4,8 @@ package org.jetbrains.idea.devkit.navigation.structure; import com.intellij.icons.AllIcons; -import com.intellij.ide.structureView.newStructureView.StructureViewComponent.StructureViewTreeElementWrapper; import com.intellij.ide.util.treeView.smartTree.TreeElement; +import com.intellij.ide.util.treeView.smartTree.TreeElementWrapper; import com.intellij.openapi.application.PluginPathManager; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.TestDataPath; @@ -13,6 +13,7 @@ import com.intellij.testFramework.builders.JavaModuleFixtureBuilder; import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase; import com.intellij.ui.components.JBList; import com.intellij.util.PathUtil; +import com.intellij.util.ui.tree.TreeUtil; import com.intellij.util.xmlb.annotations.Attribute; import java.util.stream.Stream; @@ -27,7 +28,7 @@ public class PluginDescriptorStructureTest extends JavaCodeInsightFixtureTestCas } @Override - protected void tuneFixture(JavaModuleFixtureBuilder moduleBuilder) throws Exception { + protected void tuneFixture(JavaModuleFixtureBuilder moduleBuilder) { moduleBuilder.addLibrary("util", PathUtil.getJarPathForClass(Attribute.class)); moduleBuilder.addLibrary("jblist", PathUtil.getJarPathForClass(JBList.class)); } @@ -47,7 +48,7 @@ public class PluginDescriptorStructureTest extends JavaCodeInsightFixtureTestCas myFixture.openFileInEditor(file); myFixture.testStructureView(component -> { - StructureViewTreeElementWrapper root = (StructureViewTreeElementWrapper)component.getTreeStructure().getRootElement(); + TreeElementWrapper root = (TreeElementWrapper)TreeUtil.getUserObject(component.getTree().getModel().getRoot()); TreeElement[] topLevelNodes = root.getValue().getChildren(); assertSize(13, topLevelNodes); diff --git a/plugins/java-decompiler/plugin/test/org/jetbrains/java/decompiler/IdeaDecompilerTest.kt b/plugins/java-decompiler/plugin/test/org/jetbrains/java/decompiler/IdeaDecompilerTest.kt index cf605238dd38..280cd1d9dc08 100644 --- a/plugins/java-decompiler/plugin/test/org/jetbrains/java/decompiler/IdeaDecompilerTest.kt +++ b/plugins/java-decompiler/plugin/test/org/jetbrains/java/decompiler/IdeaDecompilerTest.kt @@ -23,7 +23,6 @@ import com.intellij.ide.highlighter.ArchiveFileType import com.intellij.ide.structureView.StructureViewBuilder 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.openapi.application.PluginPathManager import com.intellij.openapi.fileEditor.FileEditorManager import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx @@ -143,9 +142,7 @@ class IdeaDecompilerTest : LightCodeInsightFixtureTestCase() { Disposer.register(myFixture.testRootDisposable, viewComponent) viewComponent.setActionActive(JavaAnonymousClassesNodeProvider.ID, true) - val treeStructure = viewComponent.treeStructure - PlatformTestUtil.updateRecursively(treeStructure.rootElement as AbstractTreeNode<*>) - PlatformTestUtil.assertTreeStructureEquals(treeStructure, """ + PlatformTestUtil.assertTreeStructureEquals(viewComponent.tree.model, """ StructureView.java StructureView B diff --git a/python/python-rest/test/com/jetbrains/rest/RestStructureViewTest.java b/python/python-rest/test/com/jetbrains/rest/RestStructureViewTest.java index 1ffcbdc33563..c58fd22e8f99 100644 --- a/python/python-rest/test/com/jetbrains/rest/RestStructureViewTest.java +++ b/python/python-rest/test/com/jetbrains/rest/RestStructureViewTest.java @@ -58,6 +58,6 @@ public class RestStructureViewTest extends RestFixtureTestCase { private void doTest(final String expected) { myFixture.configureByFile("/structureView/" + getTestName(true) + ".rst"); - myFixture.testStructureView(component -> assertTreeEqual(component.getTree(), expected)); + myFixture.testStructureView(svc -> assertTreeEqual(svc.getTree(), expected)); } }