From 398f99ffe34fe664ca47c67dadf9e1c0d44c415b Mon Sep 17 00:00:00 2001 From: Sergey Malenkov Date: Wed, 13 Nov 2019 22:19:05 +0300 Subject: [PATCH] IJP-177: Write tests for Project and Scope Views GitOrigin-RevId: e6926d4eab4889e1858644fb519a5cb034311c35 --- .../projectView/AbstractProjectViewTest.kt | 54 +++++ .../intellij/projectView/PackagesPaneTest.kt | 190 ++++++++++++++++++ .../intellij/projectView/ProblemsPaneTest.kt | 190 ++++++++++++++++++ .../projectView/ProjectFilesPaneTest.kt | 190 ++++++++++++++++++ .../intellij/projectView/ProjectPaneTest.kt | 186 +++++++++++++++++ .../projectView/ScopeViewPaneTest.java | 25 --- .../ide/projectView/impl/ProjectViewState.kt | 3 + .../wm/impl/ProjectToolWindowTest.java | 6 +- .../testFramework/PlatformTestUtil.java | 2 +- 9 files changed, 817 insertions(+), 29 deletions(-) create mode 100644 java/java-tests/testSrc/com/intellij/projectView/AbstractProjectViewTest.kt create mode 100644 java/java-tests/testSrc/com/intellij/projectView/PackagesPaneTest.kt create mode 100644 java/java-tests/testSrc/com/intellij/projectView/ProblemsPaneTest.kt create mode 100644 java/java-tests/testSrc/com/intellij/projectView/ProjectFilesPaneTest.kt create mode 100644 java/java-tests/testSrc/com/intellij/projectView/ProjectPaneTest.kt diff --git a/java/java-tests/testSrc/com/intellij/projectView/AbstractProjectViewTest.kt b/java/java-tests/testSrc/com/intellij/projectView/AbstractProjectViewTest.kt new file mode 100644 index 000000000000..3088ea73afcc --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/projectView/AbstractProjectViewTest.kt @@ -0,0 +1,54 @@ +// Copyright 2000-2019 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.projectView.ProjectView +import com.intellij.ide.projectView.ProjectViewSettings +import com.intellij.ide.projectView.impl.* +import com.intellij.ide.scopeView.ScopeViewPane +import com.intellij.psi.search.scope.ProblemsScope +import com.intellij.psi.search.scope.ProjectFilesScope +import com.intellij.psi.search.scope.packageSet.NamedScope +import com.intellij.testFramework.PlatformTestUtil +import com.intellij.testFramework.TestSourceBasedTestCase +import com.intellij.ui.tree.TreeTestUtil +import javax.swing.JTree + +/** + * @author sergey.malenkov + */ +abstract class AbstractProjectViewTest : TestSourceBasedTestCase() { + override fun getTestPath(): String? = null + + protected val projectView: ProjectViewImpl + get() = ProjectView.getInstance(project) as ProjectViewImpl + + protected val currentSettings: ProjectViewSettings + get() = ProjectViewSettings.Delegate(project, projectView.currentViewId) + + protected val currentPane: AbstractProjectViewPane + get() = projectView.currentProjectViewPane + + protected val currentTree: JTree + get() = currentPane.tree + + protected fun createTreeTest() = TreeTestUtil(currentTree) + + protected fun waitWhileBusy() = PlatformTestUtil.waitWhileBusy(currentTree) + + protected fun selectProjectPane() = selectProjectViewPane(ProjectViewPane.ID, null) + + protected fun selectPackagesPane() = selectProjectViewPane(PackageViewPane.ID, null) + + protected fun selectProjectFilesPane() = selectScopeViewPane(ProjectFilesScope.INSTANCE) + + protected fun selectProblemsPane() = selectScopeViewPane(ProblemsScope.INSTANCE) + + protected fun selectScopeViewPane(scope: NamedScope) = selectProjectViewPane(ScopeViewPane.ID, scope.toString() + "; " + scope.javaClass) + + private fun selectProjectViewPane(id: String, subId: String?) { + PlatformTestUtil.waitForCallback(projectView.changeViewCB(id, subId)) + assertEquals(id, currentPane.id) + if (subId != null) assertEquals(subId, currentPane.subId) + waitWhileBusy() + } +} diff --git a/java/java-tests/testSrc/com/intellij/projectView/PackagesPaneTest.kt b/java/java-tests/testSrc/com/intellij/projectView/PackagesPaneTest.kt new file mode 100644 index 000000000000..0ed6f46ea5f3 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/projectView/PackagesPaneTest.kt @@ -0,0 +1,190 @@ +// Copyright 2000-2019 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.projectView.ProjectViewSettings +import com.intellij.ide.projectView.ViewSettings +import com.intellij.ide.projectView.impl.ProjectViewState +import com.intellij.ide.util.treeView.NodeOptions +import com.intellij.testFramework.PsiTestUtil +import com.intellij.util.io.directoryContent +import com.intellij.util.io.generateInVirtualTempDir + +/** + * @author sergey.malenkov + */ +class PackagesPaneTest : AbstractProjectViewTest() { + override fun setUp() { + super.setUp() + selectPackagesPane() + } + + fun `test default settings`() { + val settings = currentSettings // mutable delegate + val state = ProjectViewState.getInstance(project) + + // ProjectViewSettings + + val defaultShowExcludedFiles = ProjectViewSettings.Immutable.DEFAULT.isShowExcludedFiles + assertEquals(false, settings.isShowExcludedFiles) // not supported in the Packages view + state.showExcludedFiles = !defaultShowExcludedFiles + assertEquals(false, settings.isShowExcludedFiles) // not supported in the Packages view + + val defaultShowVisibilityIcons = ProjectViewSettings.Immutable.DEFAULT.isShowVisibilityIcons + assertEquals(defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + state.showVisibilityIcons = !defaultShowVisibilityIcons + assertEquals(!defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + + val defaultUseFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Packages view + state.useFileNestingRules = !defaultUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Packages view + + // ViewSettings + + val defaultFoldersAlwaysOnTop = ViewSettings.Immutable.DEFAULT.isFoldersAlwaysOnTop + assertEquals(defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + state.foldersAlwaysOnTop = !defaultFoldersAlwaysOnTop + assertEquals(!defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + + val defaultShowMembers = ViewSettings.Immutable.DEFAULT.isShowMembers + assertEquals(defaultShowMembers, settings.isShowMembers) + state.showMembers = !defaultShowMembers + assertEquals(!defaultShowMembers, settings.isShowMembers) + + val defaultStructureView = ViewSettings.Immutable.DEFAULT.isStructureView + assertEquals(defaultStructureView, settings.isStructureView) + + val defaultShowModules = ViewSettings.Immutable.DEFAULT.isShowModules + assertEquals(defaultShowModules, settings.isShowModules) + state.showModules = !defaultShowModules + assertEquals(!defaultShowModules, settings.isShowModules) + + val defaultFlattenModules = ViewSettings.Immutable.DEFAULT.isFlattenModules + assertEquals(defaultFlattenModules, settings.isFlattenModules) + state.flattenModules = !defaultFlattenModules + assertEquals(false, settings.isFlattenModules) // depends on show modules + state.showModules = true // to test dependency of FlattenModules and ShowModules + assertEquals(!defaultFlattenModules, settings.isFlattenModules) + + val defaultShowURL = ViewSettings.Immutable.DEFAULT.isShowURL + assertEquals(defaultShowURL, settings.isShowURL) + state.showURL = !defaultShowURL + assertEquals(defaultShowURL, settings.isShowURL) // TODO: cannot be changed now + + // NodeOptions + + val defaultFlattenPackages = NodeOptions.Immutable.DEFAULT.isFlattenPackages + assertEquals(defaultFlattenPackages, settings.isFlattenPackages) + state.flattenPackages = !defaultFlattenPackages + assertEquals(!defaultFlattenPackages, settings.isFlattenPackages) + + val defaultAbbreviatePackageNames = NodeOptions.Immutable.DEFAULT.isAbbreviatePackageNames + assertEquals(defaultAbbreviatePackageNames, settings.isAbbreviatePackageNames) + state.abbreviatePackageNames = !defaultAbbreviatePackageNames + assertEquals(!defaultAbbreviatePackageNames, settings.isAbbreviatePackageNames) + + val defaultHideEmptyMiddlePackages = NodeOptions.Immutable.DEFAULT.isHideEmptyMiddlePackages + assertEquals(defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + state.hideEmptyMiddlePackages = !defaultHideEmptyMiddlePackages + assertEquals(!defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + + val defaultCompactDirectories = NodeOptions.Immutable.DEFAULT.isCompactDirectories + assertEquals(false, settings.isCompactDirectories) // not supported in the Packages view + state.compactDirectories = !defaultCompactDirectories + assertEquals(false, settings.isCompactDirectories) // not supported in the Packages view + + val defaultShowLibraryContents = NodeOptions.Immutable.DEFAULT.isShowLibraryContents + assertEquals(defaultShowLibraryContents, settings.isShowLibraryContents) + state.showLibraryContents = !defaultShowLibraryContents + assertEquals(!defaultShowLibraryContents, settings.isShowLibraryContents) + } + + fun `test default settings with modules in project`() { + val root = directoryContent { + dir("one") {} + dir("two") {} + }.generateInVirtualTempDir() + PsiTestUtil.addContentRoot(createModule("qualified.one"), root.findChild("one")!!) + PsiTestUtil.addContentRoot(createModule("qualified.two"), root.findChild("two")!!) + waitWhileBusy() + + val settings = currentSettings // mutable delegate + val state = ProjectViewState.getInstance(project) + + // ProjectViewSettings + + val defaultShowExcludedFiles = ProjectViewSettings.Immutable.DEFAULT.isShowExcludedFiles + assertEquals(false, settings.isShowExcludedFiles) // not supported in the Packages view + state.showExcludedFiles = !defaultShowExcludedFiles + assertEquals(false, settings.isShowExcludedFiles) // not supported in the Packages view + + val defaultShowVisibilityIcons = ProjectViewSettings.Immutable.DEFAULT.isShowVisibilityIcons + assertEquals(defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + state.showVisibilityIcons = !defaultShowVisibilityIcons + assertEquals(!defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + + val defaultUseFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Packages view + state.useFileNestingRules = !defaultUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Packages view + + // ViewSettings + + val defaultFoldersAlwaysOnTop = ViewSettings.Immutable.DEFAULT.isFoldersAlwaysOnTop + assertEquals(defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + state.foldersAlwaysOnTop = !defaultFoldersAlwaysOnTop + assertEquals(!defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + + val defaultShowMembers = ViewSettings.Immutable.DEFAULT.isShowMembers + assertEquals(defaultShowMembers, settings.isShowMembers) + state.showMembers = !defaultShowMembers + assertEquals(!defaultShowMembers, settings.isShowMembers) + + val defaultStructureView = ViewSettings.Immutable.DEFAULT.isStructureView + assertEquals(defaultStructureView, settings.isStructureView) + + val defaultShowModules = ViewSettings.Immutable.DEFAULT.isShowModules + assertEquals(defaultShowModules, settings.isShowModules) + state.showModules = !defaultShowModules + assertEquals(!defaultShowModules, settings.isShowModules) + + val defaultFlattenModules = ViewSettings.Immutable.DEFAULT.isFlattenModules + assertEquals(defaultFlattenModules, settings.isFlattenModules) + state.flattenModules = !defaultFlattenModules + assertEquals(false, settings.isFlattenModules) // depends on show modules + state.showModules = true // to test dependency of FlattenModules and ShowModules + assertEquals(!defaultFlattenModules, settings.isFlattenModules) + + val defaultShowURL = ViewSettings.Immutable.DEFAULT.isShowURL + assertEquals(defaultShowURL, settings.isShowURL) + state.showURL = !defaultShowURL + assertEquals(defaultShowURL, settings.isShowURL) // TODO: cannot be changed now + + // NodeOptions + + val defaultFlattenPackages = NodeOptions.Immutable.DEFAULT.isFlattenPackages + assertEquals(defaultFlattenPackages, settings.isFlattenPackages) + state.flattenPackages = !defaultFlattenPackages + assertEquals(!defaultFlattenPackages, settings.isFlattenPackages) + + val defaultAbbreviatePackageNames = NodeOptions.Immutable.DEFAULT.isAbbreviatePackageNames + assertEquals(defaultAbbreviatePackageNames, settings.isAbbreviatePackageNames) + state.abbreviatePackageNames = !defaultAbbreviatePackageNames + assertEquals(!defaultAbbreviatePackageNames, settings.isAbbreviatePackageNames) + + val defaultHideEmptyMiddlePackages = NodeOptions.Immutable.DEFAULT.isHideEmptyMiddlePackages + assertEquals(defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + state.hideEmptyMiddlePackages = !defaultHideEmptyMiddlePackages + assertEquals(!defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + + val defaultCompactDirectories = NodeOptions.Immutable.DEFAULT.isCompactDirectories + assertEquals(false, settings.isCompactDirectories) // not supported in the Project view + state.compactDirectories = !defaultCompactDirectories + assertEquals(false, settings.isCompactDirectories) // not supported in the Project view + + val defaultShowLibraryContents = NodeOptions.Immutable.DEFAULT.isShowLibraryContents + assertEquals(defaultShowLibraryContents, settings.isShowLibraryContents) + state.showLibraryContents = !defaultShowLibraryContents + assertEquals(!defaultShowLibraryContents, settings.isShowLibraryContents) + } +} diff --git a/java/java-tests/testSrc/com/intellij/projectView/ProblemsPaneTest.kt b/java/java-tests/testSrc/com/intellij/projectView/ProblemsPaneTest.kt new file mode 100644 index 000000000000..c91cba269989 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/projectView/ProblemsPaneTest.kt @@ -0,0 +1,190 @@ +// Copyright 2000-2019 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.projectView.ProjectViewSettings +import com.intellij.ide.projectView.ViewSettings +import com.intellij.ide.projectView.impl.ProjectViewState +import com.intellij.ide.util.treeView.NodeOptions +import com.intellij.testFramework.PsiTestUtil +import com.intellij.util.io.directoryContent +import com.intellij.util.io.generateInVirtualTempDir + +/** + * @author sergey.malenkov + */ +class ProblemsPaneTest : AbstractProjectViewTest() { + override fun setUp() { + super.setUp() + selectProblemsPane() + } + + fun `test default settings`() { + val settings = currentSettings // mutable delegate + val state = ProjectViewState.getInstance(project) + + // ProjectViewSettings + + val defaultShowExcludedFiles = ProjectViewSettings.Immutable.DEFAULT.isShowExcludedFiles + assertEquals(defaultShowExcludedFiles, settings.isShowExcludedFiles) + state.showExcludedFiles = !defaultShowExcludedFiles + assertEquals(!defaultShowExcludedFiles, settings.isShowExcludedFiles) + + val defaultShowVisibilityIcons = ProjectViewSettings.Immutable.DEFAULT.isShowVisibilityIcons + assertEquals(defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + state.showVisibilityIcons = !defaultShowVisibilityIcons + assertEquals(!defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + + val defaultUseFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Scope view + state.useFileNestingRules = !defaultUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Scope view + + // ViewSettings + + val defaultFoldersAlwaysOnTop = ViewSettings.Immutable.DEFAULT.isFoldersAlwaysOnTop + assertEquals(defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + state.foldersAlwaysOnTop = !defaultFoldersAlwaysOnTop + assertEquals(!defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + + val defaultShowMembers = ViewSettings.Immutable.DEFAULT.isShowMembers + assertEquals(defaultShowMembers, settings.isShowMembers) + state.showMembers = !defaultShowMembers + assertEquals(!defaultShowMembers, settings.isShowMembers) + + val defaultStructureView = ViewSettings.Immutable.DEFAULT.isStructureView + assertEquals(defaultStructureView, settings.isStructureView) + + val defaultShowModules = ViewSettings.Immutable.DEFAULT.isShowModules + assertEquals(defaultShowModules, settings.isShowModules) + state.showModules = !defaultShowModules + assertEquals(!defaultShowModules, settings.isShowModules) + + val defaultFlattenModules = ViewSettings.Immutable.DEFAULT.isFlattenModules + assertEquals(defaultFlattenModules, settings.isFlattenModules) + state.flattenModules = !defaultFlattenModules + assertEquals(false, settings.isFlattenModules) // depends on show modules + state.showModules = true // to test dependency of FlattenModules and ShowModules + assertEquals(!defaultFlattenModules, settings.isFlattenModules) + + val defaultShowURL = ViewSettings.Immutable.DEFAULT.isShowURL + assertEquals(defaultShowURL, settings.isShowURL) + state.showURL = !defaultShowURL + assertEquals(defaultShowURL, settings.isShowURL) // TODO: cannot be changed now + + // NodeOptions + + val defaultFlattenPackages = NodeOptions.Immutable.DEFAULT.isFlattenPackages + assertEquals(defaultFlattenPackages, settings.isFlattenPackages) + state.flattenPackages = !defaultFlattenPackages + assertEquals(!defaultFlattenPackages, settings.isFlattenPackages) + + val defaultAbbreviatePackageNames = NodeOptions.Immutable.DEFAULT.isAbbreviatePackageNames + assertEquals(false, settings.isAbbreviatePackageNames) // not supported in the Scope view + state.abbreviatePackageNames = !defaultAbbreviatePackageNames + assertEquals(false, settings.isAbbreviatePackageNames) // not supported in the Scope view + + val defaultHideEmptyMiddlePackages = NodeOptions.Immutable.DEFAULT.isHideEmptyMiddlePackages + assertEquals(defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + state.hideEmptyMiddlePackages = !defaultHideEmptyMiddlePackages + assertEquals(!defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + + val defaultCompactDirectories = NodeOptions.Immutable.DEFAULT.isCompactDirectories + assertEquals(defaultCompactDirectories, settings.isCompactDirectories) + state.compactDirectories = !defaultCompactDirectories + assertEquals(!defaultCompactDirectories, settings.isCompactDirectories) + + val defaultShowLibraryContents = NodeOptions.Immutable.DEFAULT.isShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Scope view + state.showLibraryContents = !defaultShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Scope view + } + + fun `test default settings with modules in project`() { + val root = directoryContent { + dir("one") {} + dir("two") {} + }.generateInVirtualTempDir() + PsiTestUtil.addContentRoot(createModule("qualified.one"), root.findChild("one")!!) + PsiTestUtil.addContentRoot(createModule("qualified.two"), root.findChild("two")!!) + waitWhileBusy() + + val settings = currentSettings // mutable delegate + val state = ProjectViewState.getInstance(project) + + // ProjectViewSettings + + val defaultShowExcludedFiles = ProjectViewSettings.Immutable.DEFAULT.isShowExcludedFiles + assertEquals(defaultShowExcludedFiles, settings.isShowExcludedFiles) + state.showExcludedFiles = !defaultShowExcludedFiles + assertEquals(!defaultShowExcludedFiles, settings.isShowExcludedFiles) + + val defaultShowVisibilityIcons = ProjectViewSettings.Immutable.DEFAULT.isShowVisibilityIcons + assertEquals(defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + state.showVisibilityIcons = !defaultShowVisibilityIcons + assertEquals(!defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + + val defaultUseFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Scope view + state.useFileNestingRules = !defaultUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Scope view + + // ViewSettings + + val defaultFoldersAlwaysOnTop = ViewSettings.Immutable.DEFAULT.isFoldersAlwaysOnTop + assertEquals(defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + state.foldersAlwaysOnTop = !defaultFoldersAlwaysOnTop + assertEquals(!defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + + val defaultShowMembers = ViewSettings.Immutable.DEFAULT.isShowMembers + assertEquals(defaultShowMembers, settings.isShowMembers) + state.showMembers = !defaultShowMembers + assertEquals(!defaultShowMembers, settings.isShowMembers) + + val defaultStructureView = ViewSettings.Immutable.DEFAULT.isStructureView + assertEquals(defaultStructureView, settings.isStructureView) + + val defaultShowModules = ViewSettings.Immutable.DEFAULT.isShowModules + assertEquals(defaultShowModules, settings.isShowModules) + state.showModules = !defaultShowModules + assertEquals(!defaultShowModules, settings.isShowModules) + + val defaultFlattenModules = ViewSettings.Immutable.DEFAULT.isFlattenModules + assertEquals(defaultFlattenModules, settings.isFlattenModules) + state.flattenModules = !defaultFlattenModules + assertEquals(false, settings.isFlattenModules) // depends on show modules + state.showModules = true // to test dependency of FlattenModules and ShowModules + assertEquals(!defaultFlattenModules, settings.isFlattenModules) + + val defaultShowURL = ViewSettings.Immutable.DEFAULT.isShowURL + assertEquals(defaultShowURL, settings.isShowURL) + state.showURL = !defaultShowURL + assertEquals(defaultShowURL, settings.isShowURL) // TODO: cannot be changed now + + // NodeOptions + + val defaultFlattenPackages = NodeOptions.Immutable.DEFAULT.isFlattenPackages + assertEquals(defaultFlattenPackages, settings.isFlattenPackages) + state.flattenPackages = !defaultFlattenPackages + assertEquals(!defaultFlattenPackages, settings.isFlattenPackages) + + val defaultAbbreviatePackageNames = NodeOptions.Immutable.DEFAULT.isAbbreviatePackageNames + assertEquals(false, settings.isAbbreviatePackageNames) // not supported in the Scope view + state.abbreviatePackageNames = !defaultAbbreviatePackageNames + assertEquals(false, settings.isAbbreviatePackageNames) // not supported in the Scope view + + val defaultHideEmptyMiddlePackages = NodeOptions.Immutable.DEFAULT.isHideEmptyMiddlePackages + assertEquals(defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + state.hideEmptyMiddlePackages = !defaultHideEmptyMiddlePackages + assertEquals(!defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + + val defaultCompactDirectories = NodeOptions.Immutable.DEFAULT.isCompactDirectories + assertEquals(defaultCompactDirectories, settings.isCompactDirectories) + state.compactDirectories = !defaultCompactDirectories + assertEquals(!defaultCompactDirectories, settings.isCompactDirectories) + + val defaultShowLibraryContents = NodeOptions.Immutable.DEFAULT.isShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Scope view + state.showLibraryContents = !defaultShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Scope view + } +} diff --git a/java/java-tests/testSrc/com/intellij/projectView/ProjectFilesPaneTest.kt b/java/java-tests/testSrc/com/intellij/projectView/ProjectFilesPaneTest.kt new file mode 100644 index 000000000000..aa2160053368 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/projectView/ProjectFilesPaneTest.kt @@ -0,0 +1,190 @@ +// Copyright 2000-2019 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.projectView.ProjectViewSettings +import com.intellij.ide.projectView.ViewSettings +import com.intellij.ide.projectView.impl.ProjectViewState +import com.intellij.ide.util.treeView.NodeOptions +import com.intellij.testFramework.PsiTestUtil +import com.intellij.util.io.directoryContent +import com.intellij.util.io.generateInVirtualTempDir + +/** + * @author sergey.malenkov + */ +class ProjectFilesPaneTest : AbstractProjectViewTest() { + override fun setUp() { + super.setUp() + selectProjectFilesPane() + } + + fun `test default settings`() { + val settings = currentSettings // mutable delegate + val state = ProjectViewState.getInstance(project) + + // ProjectViewSettings + + val defaultShowExcludedFiles = ProjectViewSettings.Immutable.DEFAULT.isShowExcludedFiles + assertEquals(defaultShowExcludedFiles, settings.isShowExcludedFiles) + state.showExcludedFiles = !defaultShowExcludedFiles + assertEquals(!defaultShowExcludedFiles, settings.isShowExcludedFiles) + + val defaultShowVisibilityIcons = ProjectViewSettings.Immutable.DEFAULT.isShowVisibilityIcons + assertEquals(defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + state.showVisibilityIcons = !defaultShowVisibilityIcons + assertEquals(!defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + + val defaultUseFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Scope view + state.useFileNestingRules = !defaultUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Scope view + + // ViewSettings + + val defaultFoldersAlwaysOnTop = ViewSettings.Immutable.DEFAULT.isFoldersAlwaysOnTop + assertEquals(defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + state.foldersAlwaysOnTop = !defaultFoldersAlwaysOnTop + assertEquals(!defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + + val defaultShowMembers = ViewSettings.Immutable.DEFAULT.isShowMembers + assertEquals(defaultShowMembers, settings.isShowMembers) + state.showMembers = !defaultShowMembers + assertEquals(!defaultShowMembers, settings.isShowMembers) + + val defaultStructureView = ViewSettings.Immutable.DEFAULT.isStructureView + assertEquals(defaultStructureView, settings.isStructureView) + + val defaultShowModules = ViewSettings.Immutable.DEFAULT.isShowModules + assertEquals(defaultShowModules, settings.isShowModules) + state.showModules = !defaultShowModules + assertEquals(!defaultShowModules, settings.isShowModules) + + val defaultFlattenModules = ViewSettings.Immutable.DEFAULT.isFlattenModules + assertEquals(defaultFlattenModules, settings.isFlattenModules) + state.flattenModules = !defaultFlattenModules + assertEquals(false, settings.isFlattenModules) // depends on show modules + state.showModules = true // to test dependency of FlattenModules and ShowModules + assertEquals(!defaultFlattenModules, settings.isFlattenModules) + + val defaultShowURL = ViewSettings.Immutable.DEFAULT.isShowURL + assertEquals(defaultShowURL, settings.isShowURL) + state.showURL = !defaultShowURL + assertEquals(defaultShowURL, settings.isShowURL) // TODO: cannot be changed now + + // NodeOptions + + val defaultFlattenPackages = NodeOptions.Immutable.DEFAULT.isFlattenPackages + assertEquals(defaultFlattenPackages, settings.isFlattenPackages) + state.flattenPackages = !defaultFlattenPackages + assertEquals(!defaultFlattenPackages, settings.isFlattenPackages) + + val defaultAbbreviatePackageNames = NodeOptions.Immutable.DEFAULT.isAbbreviatePackageNames + assertEquals(false, settings.isAbbreviatePackageNames) // not supported in the Scope view + state.abbreviatePackageNames = !defaultAbbreviatePackageNames + assertEquals(false, settings.isAbbreviatePackageNames) // not supported in the Scope view + + val defaultHideEmptyMiddlePackages = NodeOptions.Immutable.DEFAULT.isHideEmptyMiddlePackages + assertEquals(defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + state.hideEmptyMiddlePackages = !defaultHideEmptyMiddlePackages + assertEquals(!defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + + val defaultCompactDirectories = NodeOptions.Immutable.DEFAULT.isCompactDirectories + assertEquals(defaultCompactDirectories, settings.isCompactDirectories) + state.compactDirectories = !defaultCompactDirectories + assertEquals(!defaultCompactDirectories, settings.isCompactDirectories) + + val defaultShowLibraryContents = NodeOptions.Immutable.DEFAULT.isShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Scope view + state.showLibraryContents = !defaultShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Scope view + } + + fun `test default settings with modules in project`() { + val root = directoryContent { + dir("one") {} + dir("two") {} + }.generateInVirtualTempDir() + PsiTestUtil.addContentRoot(createModule("qualified.one"), root.findChild("one")!!) + PsiTestUtil.addContentRoot(createModule("qualified.two"), root.findChild("two")!!) + waitWhileBusy() + + val settings = currentSettings // mutable delegate + val state = ProjectViewState.getInstance(project) + + // ProjectViewSettings + + val defaultShowExcludedFiles = ProjectViewSettings.Immutable.DEFAULT.isShowExcludedFiles + assertEquals(defaultShowExcludedFiles, settings.isShowExcludedFiles) + state.showExcludedFiles = !defaultShowExcludedFiles + assertEquals(!defaultShowExcludedFiles, settings.isShowExcludedFiles) + + val defaultShowVisibilityIcons = ProjectViewSettings.Immutable.DEFAULT.isShowVisibilityIcons + assertEquals(defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + state.showVisibilityIcons = !defaultShowVisibilityIcons + assertEquals(!defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + + val defaultUseFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Scope view + state.useFileNestingRules = !defaultUseFileNestingRules + assertEquals(false, settings.isUseFileNestingRules) // not supported in the Scope view + + // ViewSettings + + val defaultFoldersAlwaysOnTop = ViewSettings.Immutable.DEFAULT.isFoldersAlwaysOnTop + assertEquals(defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + state.foldersAlwaysOnTop = !defaultFoldersAlwaysOnTop + assertEquals(!defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + + val defaultShowMembers = ViewSettings.Immutable.DEFAULT.isShowMembers + assertEquals(defaultShowMembers, settings.isShowMembers) + state.showMembers = !defaultShowMembers + assertEquals(!defaultShowMembers, settings.isShowMembers) + + val defaultStructureView = ViewSettings.Immutable.DEFAULT.isStructureView + assertEquals(defaultStructureView, settings.isStructureView) + + val defaultShowModules = ViewSettings.Immutable.DEFAULT.isShowModules + assertEquals(defaultShowModules, settings.isShowModules) + state.showModules = !defaultShowModules + assertEquals(!defaultShowModules, settings.isShowModules) + + val defaultFlattenModules = ViewSettings.Immutable.DEFAULT.isFlattenModules + assertEquals(defaultFlattenModules, settings.isFlattenModules) + state.flattenModules = !defaultFlattenModules + assertEquals(false, settings.isFlattenModules) // depends on show modules + state.showModules = true // to test dependency of FlattenModules and ShowModules + assertEquals(!defaultFlattenModules, settings.isFlattenModules) + + val defaultShowURL = ViewSettings.Immutable.DEFAULT.isShowURL + assertEquals(defaultShowURL, settings.isShowURL) + state.showURL = !defaultShowURL + assertEquals(defaultShowURL, settings.isShowURL) // TODO: cannot be changed now + + // NodeOptions + + val defaultFlattenPackages = NodeOptions.Immutable.DEFAULT.isFlattenPackages + assertEquals(defaultFlattenPackages, settings.isFlattenPackages) + state.flattenPackages = !defaultFlattenPackages + assertEquals(!defaultFlattenPackages, settings.isFlattenPackages) + + val defaultAbbreviatePackageNames = NodeOptions.Immutable.DEFAULT.isAbbreviatePackageNames + assertEquals(false, settings.isAbbreviatePackageNames) // not supported in the Scope view + state.abbreviatePackageNames = !defaultAbbreviatePackageNames + assertEquals(false, settings.isAbbreviatePackageNames) // not supported in the Scope view + + val defaultHideEmptyMiddlePackages = NodeOptions.Immutable.DEFAULT.isHideEmptyMiddlePackages + assertEquals(defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + state.hideEmptyMiddlePackages = !defaultHideEmptyMiddlePackages + assertEquals(!defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + + val defaultCompactDirectories = NodeOptions.Immutable.DEFAULT.isCompactDirectories + assertEquals(defaultCompactDirectories, settings.isCompactDirectories) + state.compactDirectories = !defaultCompactDirectories + assertEquals(!defaultCompactDirectories, settings.isCompactDirectories) + + val defaultShowLibraryContents = NodeOptions.Immutable.DEFAULT.isShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Scope view + state.showLibraryContents = !defaultShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Scope view + } +} diff --git a/java/java-tests/testSrc/com/intellij/projectView/ProjectPaneTest.kt b/java/java-tests/testSrc/com/intellij/projectView/ProjectPaneTest.kt new file mode 100644 index 000000000000..76fe8f6e1bae --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/projectView/ProjectPaneTest.kt @@ -0,0 +1,186 @@ +// Copyright 2000-2019 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.projectView.ProjectViewSettings +import com.intellij.ide.projectView.ViewSettings +import com.intellij.ide.projectView.impl.ProjectViewState +import com.intellij.ide.util.treeView.NodeOptions +import com.intellij.testFramework.PsiTestUtil +import com.intellij.util.io.directoryContent +import com.intellij.util.io.generateInVirtualTempDir + +/** + * @author sergey.malenkov + */ +class ProjectPaneTest : AbstractProjectViewTest() { + override fun setUp() { + super.setUp() + selectProjectPane() + } + + fun `test default settings`() { + val settings = currentSettings // mutable delegate + val state = ProjectViewState.getInstance(project) + + // ProjectViewSettings + + val defaultShowExcludedFiles = ProjectViewSettings.Immutable.DEFAULT.isShowExcludedFiles + assertEquals(defaultShowExcludedFiles, settings.isShowExcludedFiles) + state.showExcludedFiles = !defaultShowExcludedFiles + assertEquals(!defaultShowExcludedFiles, settings.isShowExcludedFiles) + + val defaultShowVisibilityIcons = ProjectViewSettings.Immutable.DEFAULT.isShowVisibilityIcons + assertEquals(defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + state.showVisibilityIcons = !defaultShowVisibilityIcons + assertEquals(!defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + + val defaultUseFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules + assertEquals(defaultUseFileNestingRules, settings.isUseFileNestingRules) + state.useFileNestingRules = !defaultUseFileNestingRules + assertEquals(defaultUseFileNestingRules, settings.isUseFileNestingRules) // TODO: cannot be changed now + + // ViewSettings + + val defaultFoldersAlwaysOnTop = ViewSettings.Immutable.DEFAULT.isFoldersAlwaysOnTop + assertEquals(defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + state.foldersAlwaysOnTop = !defaultFoldersAlwaysOnTop + assertEquals(!defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + + val defaultShowMembers = ViewSettings.Immutable.DEFAULT.isShowMembers + assertEquals(defaultShowMembers, settings.isShowMembers) + state.showMembers = !defaultShowMembers + assertEquals(!defaultShowMembers, settings.isShowMembers) + + val defaultStructureView = ViewSettings.Immutable.DEFAULT.isStructureView + assertEquals(defaultStructureView, settings.isStructureView) + + val defaultShowModules = ViewSettings.Immutable.DEFAULT.isShowModules + assertEquals(false, settings.isShowModules) // not supported in the Project view + state.showModules = !defaultShowModules + assertEquals(false, settings.isShowModules) // not supported in the Project view + + val defaultFlattenModules = ViewSettings.Immutable.DEFAULT.isFlattenModules + assertEquals(false, settings.isFlattenModules) // no modules in project + state.flattenModules = !defaultFlattenModules + assertEquals(false, settings.isFlattenModules) // no modules in project + + val defaultShowURL = ViewSettings.Immutable.DEFAULT.isShowURL + assertEquals(defaultShowURL, settings.isShowURL) + state.showURL = !defaultShowURL + assertEquals(defaultShowURL, settings.isShowURL) // TODO: cannot be changed now + + // NodeOptions + + val defaultFlattenPackages = NodeOptions.Immutable.DEFAULT.isFlattenPackages + assertEquals(defaultFlattenPackages, settings.isFlattenPackages) + state.flattenPackages = !defaultFlattenPackages + assertEquals(!defaultFlattenPackages, settings.isFlattenPackages) + + val defaultAbbreviatePackageNames = NodeOptions.Immutable.DEFAULT.isAbbreviatePackageNames + assertEquals(defaultAbbreviatePackageNames, settings.isAbbreviatePackageNames) + state.abbreviatePackageNames = !defaultAbbreviatePackageNames + assertEquals(!defaultAbbreviatePackageNames, settings.isAbbreviatePackageNames) + + val defaultHideEmptyMiddlePackages = NodeOptions.Immutable.DEFAULT.isHideEmptyMiddlePackages + assertEquals(defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + state.hideEmptyMiddlePackages = !defaultHideEmptyMiddlePackages + assertEquals(!defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + + val defaultCompactDirectories = NodeOptions.Immutable.DEFAULT.isCompactDirectories + assertEquals(false, settings.isCompactDirectories) // not supported in the Project view + state.compactDirectories = !defaultCompactDirectories + assertEquals(false, settings.isCompactDirectories) // not supported in the Project view + + val defaultShowLibraryContents = NodeOptions.Immutable.DEFAULT.isShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Project view + state.showLibraryContents = !defaultShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Project view + } + + fun `test default settings with modules in project`() { + val root = directoryContent { + dir("one") {} + dir("two") {} + }.generateInVirtualTempDir() + PsiTestUtil.addContentRoot(createModule("qualified.one"), root.findChild("one")!!) + PsiTestUtil.addContentRoot(createModule("qualified.two"), root.findChild("two")!!) + waitWhileBusy() + + val settings = currentSettings // mutable delegate + val state = ProjectViewState.getInstance(project) + + // ProjectViewSettings + + val defaultShowExcludedFiles = ProjectViewSettings.Immutable.DEFAULT.isShowExcludedFiles + assertEquals(defaultShowExcludedFiles, settings.isShowExcludedFiles) + state.showExcludedFiles = !defaultShowExcludedFiles + assertEquals(!defaultShowExcludedFiles, settings.isShowExcludedFiles) + + val defaultShowVisibilityIcons = ProjectViewSettings.Immutable.DEFAULT.isShowVisibilityIcons + assertEquals(defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + state.showVisibilityIcons = !defaultShowVisibilityIcons + assertEquals(!defaultShowVisibilityIcons, settings.isShowVisibilityIcons) + + val defaultUseFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules + assertEquals(defaultUseFileNestingRules, settings.isUseFileNestingRules) + state.useFileNestingRules = !defaultUseFileNestingRules + assertEquals(defaultUseFileNestingRules, settings.isUseFileNestingRules) // TODO: cannot be changed now + + // ViewSettings + + val defaultFoldersAlwaysOnTop = ViewSettings.Immutable.DEFAULT.isFoldersAlwaysOnTop + assertEquals(defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + state.foldersAlwaysOnTop = !defaultFoldersAlwaysOnTop + assertEquals(!defaultFoldersAlwaysOnTop, settings.isFoldersAlwaysOnTop) + + val defaultShowMembers = ViewSettings.Immutable.DEFAULT.isShowMembers + assertEquals(defaultShowMembers, settings.isShowMembers) + state.showMembers = !defaultShowMembers + assertEquals(!defaultShowMembers, settings.isShowMembers) + + val defaultStructureView = ViewSettings.Immutable.DEFAULT.isStructureView + assertEquals(defaultStructureView, settings.isStructureView) + + val defaultShowModules = ViewSettings.Immutable.DEFAULT.isShowModules + assertEquals(false, settings.isShowModules) // not supported in the Project view + state.showModules = !defaultShowModules + assertEquals(false, settings.isShowModules) // not supported in the Project view + + val defaultFlattenModules = ViewSettings.Immutable.DEFAULT.isFlattenModules + assertEquals(defaultFlattenModules, settings.isFlattenModules) + state.flattenModules = !defaultFlattenModules + assertEquals(!defaultFlattenModules, settings.isFlattenModules) + + val defaultShowURL = ViewSettings.Immutable.DEFAULT.isShowURL + assertEquals(defaultShowURL, settings.isShowURL) + state.showURL = !defaultShowURL + assertEquals(defaultShowURL, settings.isShowURL) // TODO: cannot be changed now + + // NodeOptions + + val defaultFlattenPackages = NodeOptions.Immutable.DEFAULT.isFlattenPackages + assertEquals(defaultFlattenPackages, settings.isFlattenPackages) + state.flattenPackages = !defaultFlattenPackages + assertEquals(!defaultFlattenPackages, settings.isFlattenPackages) + + val defaultAbbreviatePackageNames = NodeOptions.Immutable.DEFAULT.isAbbreviatePackageNames + assertEquals(defaultAbbreviatePackageNames, settings.isAbbreviatePackageNames) + state.abbreviatePackageNames = !defaultAbbreviatePackageNames + assertEquals(!defaultAbbreviatePackageNames, settings.isAbbreviatePackageNames) + + val defaultHideEmptyMiddlePackages = NodeOptions.Immutable.DEFAULT.isHideEmptyMiddlePackages + assertEquals(defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + state.hideEmptyMiddlePackages = !defaultHideEmptyMiddlePackages + assertEquals(!defaultHideEmptyMiddlePackages, settings.isHideEmptyMiddlePackages) + + val defaultCompactDirectories = NodeOptions.Immutable.DEFAULT.isCompactDirectories + assertEquals(false, settings.isCompactDirectories) // not supported in the Project view + state.compactDirectories = !defaultCompactDirectories + assertEquals(false, settings.isCompactDirectories) // not supported in the Project view + + val defaultShowLibraryContents = NodeOptions.Immutable.DEFAULT.isShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Project view + state.showLibraryContents = !defaultShowLibraryContents + assertEquals(false, settings.isShowLibraryContents) // not supported in the Project view + } +} diff --git a/java/java-tests/testSrc/com/intellij/projectView/ScopeViewPaneTest.java b/java/java-tests/testSrc/com/intellij/projectView/ScopeViewPaneTest.java index 080ba58cc8f5..e05f4de8ac15 100644 --- a/java/java-tests/testSrc/com/intellij/projectView/ScopeViewPaneTest.java +++ b/java/java-tests/testSrc/com/intellij/projectView/ScopeViewPaneTest.java @@ -5,7 +5,6 @@ import com.intellij.ide.IdeView; import com.intellij.ide.projectView.ProjectView; import com.intellij.ide.projectView.impl.AbstractProjectViewPane; import com.intellij.ide.projectView.impl.ProjectViewImpl; -import com.intellij.ide.projectView.impl.ProjectViewSharedSettings; import com.intellij.ide.scopeView.ScopeTreeViewPanel; import com.intellij.ide.scopeView.ScopeViewPane; import com.intellij.idea.Bombed; @@ -27,7 +26,6 @@ import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectori import com.intellij.refactoring.rename.RenameProcessor; import com.intellij.testFramework.PlatformTestUtil; import com.intellij.testFramework.TestSourceBasedTestCase; -import com.intellij.util.xmlb.XmlSerializerUtil; import org.jetbrains.annotations.NotNull; import java.util.Calendar; @@ -35,29 +33,6 @@ import java.util.Calendar; public class ScopeViewPaneTest extends TestSourceBasedTestCase { private static final int DELAY = 200; - @Override - public void setUp() throws Exception { - super.setUp(); - restoreProjectViewDefaultSettings(); - } - - @Override - public void tearDown() throws Exception { - try { - restoreProjectViewDefaultSettings(); - } - catch (Throwable e) { - addSuppressedException(e); - } - finally { - super.tearDown(); - } - } - - private static void restoreProjectViewDefaultSettings() { - XmlSerializerUtil.copyBean(new ProjectViewSharedSettings(), ProjectViewSharedSettings.Companion.getInstance()); - } - @Bombed(user = "SAM", year = 2020, month = Calendar.JANUARY, day = 10) public void testStructure() { final Project project = getProject(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewState.kt b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewState.kt index 9c5397c90e00..bd48c42348e5 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewState.kt +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewState.kt @@ -3,6 +3,7 @@ package com.intellij.ide.projectView.impl import com.intellij.ide.projectView.ProjectViewSettings import com.intellij.ide.ui.UISettings +import com.intellij.openapi.application.ApplicationManager.getApplication import com.intellij.openapi.components.* import com.intellij.openapi.project.Project import com.intellij.openapi.project.ProjectManager @@ -38,6 +39,8 @@ class ProjectViewState : PersistentStateComponent { var useFileNestingRules = ProjectViewSettings.Immutable.DEFAULT.isUseFileNestingRules override fun noStateLoaded() { + val application = getApplication() + if (application == null || application.isUnitTestMode) return // for backward compatibility abbreviatePackageNames = ProjectViewSharedSettings.instance.abbreviatePackages autoscrollFromSource = ProjectViewSharedSettings.instance.autoscrollFromSource diff --git a/platform/lang-impl/testSources/com/intellij/openapi/wm/impl/ProjectToolWindowTest.java b/platform/lang-impl/testSources/com/intellij/openapi/wm/impl/ProjectToolWindowTest.java index 8fa05854188b..6f6f0b5164fc 100644 --- a/platform/lang-impl/testSources/com/intellij/openapi/wm/impl/ProjectToolWindowTest.java +++ b/platform/lang-impl/testSources/com/intellij/openapi/wm/impl/ProjectToolWindowTest.java @@ -1,8 +1,8 @@ -// 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. +// Copyright 2000-2019 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.openapi.wm.impl; import com.intellij.ide.projectView.ProjectView; -import com.intellij.ide.projectView.impl.ProjectViewSharedSettings; +import com.intellij.ide.projectView.impl.ProjectViewState; import com.intellij.openapi.wm.ToolWindow; import com.intellij.openapi.wm.ToolWindowEP; import com.intellij.openapi.wm.ToolWindowId; @@ -28,7 +28,7 @@ public class ProjectToolWindowTest extends ToolWindowManagerTestCase { ProjectView.getInstance(getProject()); - ProjectViewSharedSettings.Companion.getInstance().setAutoscrollFromSource(true); + ProjectViewState.getInstance(getProject()).setAutoscrollFromSource(true); try { window.activate(null); diff --git a/platform/testFramework/src/com/intellij/testFramework/PlatformTestUtil.java b/platform/testFramework/src/com/intellij/testFramework/PlatformTestUtil.java index a3d695d6577b..b65bd37ef9a1 100644 --- a/platform/testFramework/src/com/intellij/testFramework/PlatformTestUtil.java +++ b/platform/testFramework/src/com/intellij/testFramework/PlatformTestUtil.java @@ -320,7 +320,7 @@ public class PlatformTestUtil { public static void waitForCallback(@NotNull ActionCallback callback) { AsyncPromise promise = new AsyncPromise<>(); - callback.doWhenDone(() -> promise.setResult(null)); + callback.doWhenDone(() -> promise.setResult(null)).doWhenRejected(() -> promise.cancel()); waitForPromise(promise); }