From 265c8faa2c064ab070acb57223e6fa5ae2256dd3 Mon Sep 17 00:00:00 2001 From: Nikolay Chashnikov Date: Thu, 2 Feb 2023 12:40:30 +0100 Subject: [PATCH] [java tests] add OrderEntryGraphTest to test ProjectFileIndex.getOrderEntriesForFile ...and remove tests from DirectoryIndexTest which become obsolete. This is needed to get rid of the obsolete DirectoryIndex class (IDEA-276394). Also, new tests cover many cases which weren't tested before. GitOrigin-RevId: 12c6285b730c41fb92836d91103dc04ee5989873 --- .../openapi/roots/impl/OrderEntryGraphTest.kt | 292 ++++++++++++++++++ .../roots/impl/DirectoryIndexTest.java | 192 +----------- 2 files changed, 296 insertions(+), 188 deletions(-) create mode 100644 java/java-tests/testSrc/com/intellij/openapi/roots/impl/OrderEntryGraphTest.kt diff --git a/java/java-tests/testSrc/com/intellij/openapi/roots/impl/OrderEntryGraphTest.kt b/java/java-tests/testSrc/com/intellij/openapi/roots/impl/OrderEntryGraphTest.kt new file mode 100644 index 000000000000..5d51a8acb161 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/openapi/roots/impl/OrderEntryGraphTest.kt @@ -0,0 +1,292 @@ +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +package com.intellij.openapi.roots.impl + +import com.intellij.openapi.application.runWriteAction +import com.intellij.openapi.module.Module +import com.intellij.openapi.roots.* +import com.intellij.openapi.roots.impl.libraries.LibraryEx +import com.intellij.openapi.vfs.VirtualFile +import com.intellij.testFramework.PsiTestUtil +import com.intellij.testFramework.UsefulTestCase +import com.intellij.testFramework.UsefulTestCase.assertEmpty +import com.intellij.testFramework.UsefulTestCase.assertOneElement +import com.intellij.testFramework.junit5.RunInEdt +import com.intellij.testFramework.junit5.TestApplication +import com.intellij.testFramework.rules.ProjectModelExtension +import org.junit.jupiter.api.Assertions.* +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.RegisterExtension +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.EnumSource + +@TestApplication +@RunInEdt +class OrderEntryGraphTest { + @JvmField + @RegisterExtension + val projectModel: ProjectModelExtension = ProjectModelExtension() + + private val fileIndex + get() = ProjectFileIndex.getInstance(projectModel.project) + + @Test + fun `module content`() { + val module = projectModel.createModule() + val moduleDir = projectModel.baseProjectDir.newVirtualDirectory("module") + val srcDir = projectModel.baseProjectDir.newVirtualDirectory("module/src") + val excludedDir = projectModel.baseProjectDir.newVirtualDirectory("module/excluded") + val excludedUnderSrcDir = projectModel.baseProjectDir.newVirtualDirectory("module/src/excluded") + PsiTestUtil.addContentRoot(module, moduleDir) + PsiTestUtil.addSourceRoot(module, srcDir) + PsiTestUtil.addExcludedRoot(module, excludedDir) + PsiTestUtil.addExcludedRoot(module, excludedUnderSrcDir) + assertNoOrderEntries(moduleDir) + assertModuleSourceEntryOnly(srcDir, module) + assertNoOrderEntries(excludedDir) + assertNoOrderEntries(excludedUnderSrcDir) + + PsiTestUtil.removeExcludedRoot(module, excludedUnderSrcDir) + assertModuleSourceEntryOnly(excludedUnderSrcDir, module) + + PsiTestUtil.removeSourceRoot(module, srcDir) + assertNoOrderEntries(srcDir) + } + + @Test + fun `dependency on module`() { + val utilModule = projectModel.createModule("util") + val utilSrcDir = projectModel.baseProjectDir.newVirtualDirectory("util/src") + PsiTestUtil.addSourceContentToRoots(utilModule, utilSrcDir) + val app1Module = projectModel.createModule("app1") + ModuleRootModificationUtil.addDependency(app1Module, utilModule) + val app2Module = projectModel.createModule("app2") + ModuleRootModificationUtil.addDependency(app2Module, utilModule, DependencyScope.COMPILE, true) + val testModule = projectModel.createModule("test") + ModuleRootModificationUtil.addDependency(testModule, utilModule, DependencyScope.TEST, false) + val runtimeModule = projectModel.createModule("runtime") + ModuleRootModificationUtil.addDependency(runtimeModule, utilModule, DependencyScope.RUNTIME, false) + val ext1Module = projectModel.createModule("ext1") + ModuleRootModificationUtil.addDependency(ext1Module, app1Module) + val ext2Module = projectModel.createModule("ext2") + ModuleRootModificationUtil.addDependency(ext2Module, app2Module) + + val orderEntries = assertIncludesModuleSourceEntry(utilSrcDir, utilModule) + assertEmpty(orderEntries.filterNot { it is ModuleOrderEntry }) + assertFromModules(orderEntries, app1Module, app2Module, testModule, runtimeModule, ext2Module) + } + + enum class LibraryLevel { PROJECT, APPLICATION } + + @ParameterizedTest + @EnumSource(LibraryLevel::class) + fun `dependency on library`(level: LibraryLevel) { + val classesDir = projectModel.baseProjectDir.newVirtualDirectory("lib/classes") + val sourceDir = projectModel.baseProjectDir.newVirtualDirectory("lib/src") + val docDir = projectModel.baseProjectDir.newVirtualDirectory("lib/doc") + val excludedDir = projectModel.baseProjectDir.newVirtualDirectory("lib/classes/excluded") + fun setupLibrary(model: LibraryEx.ModifiableModelEx) { + model.addRoot(classesDir, OrderRootType.CLASSES) + model.addRoot(sourceDir, OrderRootType.SOURCES) + model.addRoot(docDir, OrderRootType.DOCUMENTATION) + model.addExcludedRoot(excludedDir.url) + } + + val library = when (level) { + LibraryLevel.PROJECT -> projectModel.addProjectLevelLibrary("lib", ::setupLibrary) + LibraryLevel.APPLICATION -> projectModel.addApplicationLevelLibrary("lib", ::setupLibrary) + } + + val app1Module = projectModel.createModule("app1") + ModuleRootModificationUtil.addDependency(app1Module, library) + val app2Module = projectModel.createModule("app2") + ModuleRootModificationUtil.addDependency(app2Module, library, DependencyScope.COMPILE, true) + val testModule = projectModel.createModule("test") + ModuleRootModificationUtil.addDependency(testModule, library, DependencyScope.TEST, false) + val runtimeModule = projectModel.createModule("runtime") + ModuleRootModificationUtil.addDependency(runtimeModule, library, DependencyScope.RUNTIME, false) + val ext1Module = projectModel.createModule("ext1") + ModuleRootModificationUtil.addDependency(ext1Module, app1Module) + val ext2Module = projectModel.createModule("ext2") + ModuleRootModificationUtil.addDependency(ext2Module, app2Module) + + assertNoOrderEntries(excludedDir) + assertNoOrderEntries(docDir) + val entriesForClasses = fileIndex.getOrderEntriesForFile(classesDir) + assertEquals(entriesForClasses, fileIndex.getOrderEntriesForFile(sourceDir)) + assertEquals(ext2Module, (entriesForClasses.filterNot { it is LibraryOrderEntry }.single() as ModuleOrderEntry).ownerModule) + assertFromModules(entriesForClasses, app1Module, app2Module, testModule, runtimeModule, ext2Module) + } + + @Test + fun `dependency on module-level library`() { + val module = projectModel.createModule("module") + val classesDir = projectModel.baseProjectDir.newVirtualDirectory("lib/classes") + val sourceDir = projectModel.baseProjectDir.newVirtualDirectory("lib/src") + val docDir = projectModel.baseProjectDir.newVirtualDirectory("lib/doc") + val excludedDir = projectModel.baseProjectDir.newVirtualDirectory("lib/classes/excluded") + val library = projectModel.addModuleLevelLibrary(module, "lib") { model -> + model.addRoot(classesDir, OrderRootType.CLASSES) + model.addRoot(sourceDir, OrderRootType.SOURCES) + model.addRoot(docDir, OrderRootType.DOCUMENTATION) + model.addExcludedRoot(excludedDir.url) + } + + val testLibraryRoot = projectModel.baseProjectDir.newVirtualDirectory("test-lib") + val testLibrary = projectModel.addModuleLevelLibrary(module, "test-lib") { + it.addRoot(testLibraryRoot, OrderRootType.CLASSES) + } + + val runtimeLibraryRoot = projectModel.baseProjectDir.newVirtualDirectory("runtime-lib") + val runtimeLibrary = projectModel.addModuleLevelLibrary(module, "runtime-lib") { + it.addRoot(runtimeLibraryRoot, OrderRootType.CLASSES) + } + + val exportedLibraryRoot = projectModel.baseProjectDir.newVirtualDirectory("exported-lib") + val exportedLibrary = projectModel.addModuleLevelLibrary(module, "exported-lib") { + it.addRoot(exportedLibraryRoot, OrderRootType.CLASSES) + } + + ModuleRootModificationUtil.modifyModel(module) { model -> + model.findLibraryOrderEntry(testLibrary)!!.scope = DependencyScope.TEST + model.findLibraryOrderEntry(runtimeLibrary)!!.scope = DependencyScope.RUNTIME + model.findLibraryOrderEntry(exportedLibrary)!!.isExported = true + true + } + + val depModule = projectModel.createModule("dep") + ModuleRootModificationUtil.addDependency(depModule, module) + + assertNoOrderEntries(excludedDir) + assertNoOrderEntries(docDir) + val entriesForClasses = fileIndex.getOrderEntriesForFile(classesDir) + assertEquals(library, (entriesForClasses.single() as LibraryOrderEntry).library) + assertEquals(entriesForClasses, fileIndex.getOrderEntriesForFile(sourceDir)) + + val entriesForTest = fileIndex.getOrderEntriesForFile(testLibraryRoot) + assertEquals("test-lib", (entriesForTest.single() as LibraryOrderEntry).libraryName) + + val entriesForRuntime = fileIndex.getOrderEntriesForFile(runtimeLibraryRoot) + assertEquals("runtime-lib", (entriesForRuntime.single() as LibraryOrderEntry).libraryName) + + val entriesForExported = fileIndex.getOrderEntriesForFile(exportedLibraryRoot).sortedBy(OrderEntry::toString) + UsefulTestCase.assertSize(2, entriesForExported) + val (libraryEntry, moduleEntry) = entriesForExported + assertEquals(depModule, (moduleEntry as ModuleOrderEntry).ownerModule) + assertEquals("exported-lib", (libraryEntry as LibraryOrderEntry).libraryName) + } + + @Test + fun `dependency on sdk`() { + val classesDir = projectModel.baseProjectDir.newVirtualDirectory("sdk/classes") + val sourceDir = projectModel.baseProjectDir.newVirtualDirectory("sdk/src") + val docDir = projectModel.baseProjectDir.newVirtualDirectory("sdk/doc") + + val sdk = projectModel.addSdk { + it.addRoot(classesDir, OrderRootType.CLASSES) + it.addRoot(sourceDir, OrderRootType.SOURCES) + it.addRoot(docDir, OrderRootType.DOCUMENTATION) + } + + val module1 = projectModel.createModule("module1") + ModuleRootModificationUtil.setModuleSdk(module1, sdk) + val module2 = projectModel.createModule("module2") + ModuleRootModificationUtil.setModuleSdk(module2, sdk) + + assertNoOrderEntries(docDir) + val entriesForClasses = fileIndex.getOrderEntriesForFile(classesDir) + assertEquals(entriesForClasses, fileIndex.getOrderEntriesForFile(sourceDir)) + assertEmpty(entriesForClasses.filterNot { it is JdkOrderEntry }) + assertFromModules(entriesForClasses, module1, module2) + } + + @Test + fun `inherited sdk`() { + val classesDir = projectModel.baseProjectDir.newVirtualDirectory("sdk/classes") + val sdk = projectModel.addSdk { + it.addRoot(classesDir, OrderRootType.CLASSES) + } + + runWriteAction { ProjectRootManager.getInstance(projectModel.project).projectSdk = sdk } + assertNoOrderEntries(classesDir) + + val module = projectModel.createModule("module") + ModuleRootModificationUtil.setSdkInherited(module) + val entriesForClasses = fileIndex.getOrderEntriesForFile(classesDir) + assertEmpty(entriesForClasses.filterNot { it is JdkOrderEntry }) + assertFromModules(entriesForClasses, module) + } + + @Test + fun `library root under module root`() { + val module = projectModel.createModule() + val moduleRoot = projectModel.baseProjectDir.newVirtualDirectory("module") + PsiTestUtil.addSourceContentToRoots(module, moduleRoot) + val libraryClasses = projectModel.baseProjectDir.newVirtualDirectory("module/lib/classes") + val librarySource = projectModel.baseProjectDir.newVirtualDirectory("module/lib/source") + val library = projectModel.addModuleLevelLibrary(module, "lib") { + it.addRoot(libraryClasses, OrderRootType.CLASSES) + it.addRoot(librarySource, OrderRootType.SOURCES) + } + assertModuleSourceEntryOnly(moduleRoot, module) + assertEquals(library, (assertIncludesModuleSourceEntry(librarySource, module).single() as LibraryOrderEntry).library) + assertEquals(library, (fileIndex.getOrderEntriesForFile(libraryClasses).single() as LibraryOrderEntry).library) + } + + @Test + fun `module root under library root`() { + val libraryClasses = projectModel.baseProjectDir.newVirtualDirectory("lib/classes") + val librarySource = projectModel.baseProjectDir.newVirtualDirectory("lib/source") + val library = projectModel.addModuleLevelLibrary(projectModel.createModule("lib-module"), "lib") { + it.addRoot(libraryClasses, OrderRootType.CLASSES) + it.addRoot(librarySource, OrderRootType.SOURCES) + } + + val module = projectModel.createModule() + val moduleRoot1 = projectModel.baseProjectDir.newVirtualDirectory("lib/classes/module") + val moduleRoot2 = projectModel.baseProjectDir.newVirtualDirectory("lib/source/module") + PsiTestUtil.addSourceContentToRoots(module, moduleRoot1) + PsiTestUtil.addSourceContentToRoots(module, moduleRoot2) + + assertModuleSourceEntryOnly(moduleRoot1, module) + val orderEntries = assertIncludesModuleSourceEntry(moduleRoot2, module) + assertEquals(library, (orderEntries.single() as LibraryOrderEntry).library) + assertEquals(library, (fileIndex.getOrderEntriesForFile(librarySource).single() as LibraryOrderEntry).library) + assertEquals(library, (fileIndex.getOrderEntriesForFile(libraryClasses).single() as LibraryOrderEntry).library) + } + + @Test + fun `same directory as module root and library root`() { + val libraryClasses = projectModel.baseProjectDir.newVirtualDirectory("classes") + val librarySource = projectModel.baseProjectDir.newVirtualDirectory("source") + val library = projectModel.addModuleLevelLibrary(projectModel.createModule("lib-module"), "lib") { + it.addRoot(libraryClasses, OrderRootType.CLASSES) + it.addRoot(librarySource, OrderRootType.SOURCES) + } + + val module = projectModel.createModule() + PsiTestUtil.addSourceContentToRoots(module, libraryClasses) + PsiTestUtil.addSourceContentToRoots(module, librarySource) + + assertEquals(library, (assertIncludesModuleSourceEntry(librarySource, module).single() as LibraryOrderEntry).library) + assertModuleSourceEntryOnly(libraryClasses, module) + } + + private fun assertModuleSourceEntryOnly(file: VirtualFile, module: Module) { + val otherEntries = assertIncludesModuleSourceEntry(file, module) + assertEmpty(otherEntries) + } + + private fun assertIncludesModuleSourceEntry(file: VirtualFile, module: Module): List { + val orderEntries = fileIndex.getOrderEntriesForFile(file) + assertEquals(module, assertOneElement(orderEntries.filterIsInstance()).rootModel.module) + return orderEntries.filterNot { it is ModuleSourceOrderEntry } + } + + private fun assertNoOrderEntries(file: VirtualFile) { + assertEmpty(fileIndex.getOrderEntriesForFile(file)) + } + + private fun assertFromModules(entries: List, vararg modules: Module) { + UsefulTestCase.assertSameElements(entries.map { it.ownerModule }, *modules) + } +} \ No newline at end of file diff --git a/platform/platform-tests/testSrc/com/intellij/openapi/roots/impl/DirectoryIndexTest.java b/platform/platform-tests/testSrc/com/intellij/openapi/roots/impl/DirectoryIndexTest.java index 98ca9eb3303a..3c675c9bc48e 100644 --- a/platform/platform-tests/testSrc/com/intellij/openapi/roots/impl/DirectoryIndexTest.java +++ b/platform/platform-tests/testSrc/com/intellij/openapi/roots/impl/DirectoryIndexTest.java @@ -8,7 +8,6 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.*; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; -import com.intellij.openapi.vfs.VfsUtilCore; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileManager; import com.intellij.testFramework.ExtensionTestUtil; @@ -16,7 +15,6 @@ import com.intellij.testFramework.HeavyPlatformTestCase; import com.intellij.testFramework.PsiTestUtil; import com.intellij.testFramework.VfsTestUtil; import com.intellij.util.containers.ContainerUtil; -import com.intellij.workspaceModel.core.fileIndex.impl.WorkspaceFileIndexEx; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.model.java.JavaResourceRootType; @@ -25,7 +23,10 @@ import org.jetbrains.jps.model.module.JpsModuleSourceRootType; import java.io.File; import java.io.IOException; -import java.util.*; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; @HeavyPlatformTestCase.WrapInCommand public class DirectoryIndexTest extends DirectoryIndexTestCase { @@ -186,117 +187,10 @@ public class DirectoryIndexTest extends DirectoryIndexTestCase { super.tearDown(); } - //everything except order entry checks is covered by other tests - public void testDirInfos() { - assertNotInProject(myRootVFile); - - // beware: files in directory index - checkInfo(myFileLibSrc, null, false, true, "", null, null, myModule); - checkInfo(myFileLibCls, null, true, false, "", null, null, myModule); - - checkInfo(myLibAdditionalOutsideSrcDir, null, false, true, "", null, null); - checkInfo(myLibAdditionalOutsideClsDir, null, true, false, "", null, null); - assertExcludedFromProject(myLibAdditionalOutsideExcludedDir); - assertIndexableContent(Arrays.asList(myLibAdditionalOutsideSrcDir, myLibAdditionalOutsideClsDir), - Collections.singletonList(myLibAdditionalOutsideExcludedDir)); - - checkInfo(myModule1Dir, myModule, false, false, null, null, null); - checkInfo(mySrcDir1, myModule, false, false, "", mySrcDir1Folder, JavaSourceRootType.SOURCE, myModule); - checkInfo(myPack1Dir, myModule, false, false, "pack1", mySrcDir1Folder, JavaSourceRootType.SOURCE, myModule); - checkInfo(myTestSrc1, myModule, false, false, "", myTestSrc1Folder, JavaSourceRootType.TEST_SOURCE, myModule); - checkInfo(myPack2Dir, myModule, false, false, "pack2", myTestSrc1Folder, JavaSourceRootType.TEST_SOURCE, myModule); - checkInfo(myResDir, myModule, false, false, "", myResDirFolder, JavaResourceRootType.RESOURCE, myModule); - checkInfo(myTestResDir, myModule, false, false, "", myTestResDirFolder, JavaResourceRootType.TEST_RESOURCE, myModule); - - checkInfo(myLibDir, myModule, false, false, null, null, null); - checkInfo(myLibSrcDir, myModule, false, true, "", null, null, myModule2, myModule3); - checkInfo(myLibClsDir, myModule, true, false, "", null, null, myModule2, myModule3); - - assertEquals(myLibSrcDir, assertInProject(myLibSrcDir).getSourceRoot()); - - checkInfo(myModule2Dir, myModule2, false, false, null, null, null); - checkInfo(mySrcDir2, myModule2, false, false, "", mySrcDir2Folder, JavaSourceRootType.SOURCE, myModule2, myModule3); - assertExcluded(myExcludeDir, myModule2); - assertExcluded(myExcludedLibClsDir, myModule); - assertExcluded(myExcludedLibSrcDir, myModule); - - assertEquals(myModule1Dir, assertInProject(myLibClsDir).getContentRoot()); - - checkInfo(myModule3Dir, myModule3, false, false, null, null, null); - } - private static OrderEntry[] toArray(Collection orderEntries) { return orderEntries.toArray(OrderEntry.EMPTY_ARRAY); } - //everything except order entry checks is covered by NestedModuleAndLibraryRootsInProjectFileIndex - public void testModuleSourceAsLibrarySource() { - ModuleRootModificationUtil.addModuleLibrary(myModule, "someLib", Collections.emptyList(), Collections.singletonList(mySrcDir1.getUrl())); - - checkInfo(mySrcDir1, myModule, false, true, "", mySrcDir1Folder, JavaSourceRootType.SOURCE, myModule, myModule); - Collection entriesResult = myFileIndex.getOrderEntriesForFile(mySrcDir1); - OrderEntry[] entries = toArray(entriesResult); - - assertInstanceOf(entries[0], LibraryOrderEntry.class); - assertInstanceOf(entries[1], ModuleSourceOrderEntry.class); - - String packageName = WorkspaceFileIndexEx.IS_ENABLED ? "" : "testSrc"; - checkInfo(myTestSrc1, myModule, false, true, packageName, myTestSrc1Folder, JavaSourceRootType.TEST_SOURCE, myModule, myModule); - entriesResult = myFileIndex.getOrderEntriesForFile(myTestSrc1); - entries = toArray(entriesResult); - assertInstanceOf(entries[0], LibraryOrderEntry.class); - assertInstanceOf(entries[1], ModuleSourceOrderEntry.class); - } - - //everything except order entry checks is covered by NestedModuleAndLibraryRootsInProjectFileIndex - public void testModuleSourceAsLibraryClasses() { - ModuleRootModificationUtil.addModuleLibrary(myModule, "someLib", Collections.singletonList(mySrcDir1.getUrl()), Collections.emptyList()); - checkInfo(mySrcDir1, myModule, true, false, "", mySrcDir1Folder, JavaSourceRootType.SOURCE, myModule); - assertInstanceOf(assertOneElement(toArray(myFileIndex.getOrderEntriesForFile(mySrcDir1))), ModuleSourceOrderEntry.class); - } - - //everything except order entry checks is covered by NestedModuleRootsInProjectFileIndex - public void testModulesWithSameSourceContentRoot() { - // now our API allows this (ReformatCodeActionTest), although UI doesn't. Maybe API shouldn't allow it as well? - PsiTestUtil.addContentRoot(myModule2, myModule1Dir); - PsiTestUtil.addSourceRoot(myModule2, mySrcDir1); - - checkInfo(myModule1Dir, myModule, false, false, null, null, null); - checkInfo(mySrcDir1, myModule, false, false, "", mySrcDir1Folder, JavaSourceRootType.SOURCE, myModule3, myModule); - checkInfo(myTestSrc1, myModule, false, false, "", myTestSrc1Folder, JavaSourceRootType.TEST_SOURCE, myModule3, myModule); - checkInfo(myResDir, myModule, false, false, "", myResDirFolder, JavaResourceRootType.RESOURCE, myModule); - - checkInfo(mySrcDir2, myModule2, false, false, "", mySrcDir2Folder, JavaSourceRootType.SOURCE, myModule2, myModule3); - assertEquals(myModule2Dir, myFileIndex.getContentRootForFile(mySrcDir2)); - } - - //everything except order entry checks is covered by NestedModuleRootsInProjectFileIndex - public void testModuleWithSameSourceRoot() { - SourceFolder sourceFolder = PsiTestUtil.addSourceRoot(myModule2, mySrcDir1); - checkInfo(mySrcDir1, myModule2, false, false, "", sourceFolder, JavaSourceRootType.SOURCE, myModule2, myModule3); - String packageName = WorkspaceFileIndexEx.IS_ENABLED ? "" : "testSrc"; - checkInfo(myTestSrc1, myModule2, false, false, packageName, sourceFolder, JavaSourceRootType.SOURCE, myModule2, myModule3); - } - - public void testProcessingNestedContentRootsOfExcludedDirsOnCreation() { - String rootPath = myModule1Dir.getPath(); - final File f = new File(rootPath, "excludedDir/dir/anotherContentRoot"); - ApplicationManager.getApplication().runWriteAction(() -> { - ModifiableRootModel rootModel = ModuleRootManager.getInstance(myModule).getModifiableModel(); - rootModel.getContentEntries()[0] - .addExcludeFolder(VfsUtilCore.pathToUrl(f.getParentFile().getParent())); - rootModel.commit(); - - ModuleRootModificationUtil.addContentRoot(myModule2, FileUtil.toSystemIndependentName(f.getPath())); - - assertTrue(f.getPath(), f.exists() || f.mkdirs()); - LocalFileSystem.getInstance().refresh(false); - }); - - assertExcluded(LocalFileSystem.getInstance().findFileByIoFile(f.getParentFile().getParentFile()), myModule); - assertInProject(LocalFileSystem.getInstance().findFileByIoFile(f)); - } - public void testSyntheticLibraryInContent() { ModuleRootModificationUtil.addContentRoot(myModule, FileUtil.toSystemIndependentName(myModule1Dir.getPath())); checkInfo(myLibAdditionalDir, myModule, false, false, null, null, null); @@ -307,36 +201,6 @@ public class DirectoryIndexTest extends DirectoryIndexTestCase { assertIndexableContent(Arrays.asList(myLibAdditionalSrcDir, myLibAdditionalSrcFile, myLibAdditionalExcludedDir, myLibAdditionalClsDir, myLibAdditionalClsFile), null); } - public void testLibraryDirInContent() { - ModuleRootModificationUtil.addModuleLibrary(myModule, myModule1Dir.getUrl()); - - checkInfo(myModule1Dir, myModule, true, false, "", null, null, myModule); - checkInfo(mySrcDir1, myModule, true, false, "", mySrcDir1Folder, JavaSourceRootType.SOURCE, myModule); - - String packageName = WorkspaceFileIndexEx.IS_ENABLED ? null : "module2"; - checkInfo(myModule2Dir, myModule2, true, false, packageName, null, null, myModule); - checkInfo(mySrcDir2, myModule2, true, false, "", mySrcDir2Folder, JavaSourceRootType.SOURCE, myModule2, myModule3); - checkInfo(myExcludeDir, null, true, false, "module2.src2.excluded", null, null, myModule3); - - checkInfo(myLibDir, myModule, true, false, "lib", null, null, myModule); - checkInfo(myLibClsDir, myModule, true, false, "", null, null, myModule2, myModule3); - - //myModule is included into order entries instead of myModule2 because classes root for libraries dominates on source roots - checkInfo(myLibSrcDir, myModule, true, true, "", null, null, myModule, myModule3); - - checkInfo(myResDir, myModule, true, false, "", myResDirFolder, JavaResourceRootType.RESOURCE, myModule); - assertInstanceOf(assertOneElement(toArray(myFileIndex.getOrderEntriesForFile(myResDir))), ModuleSourceOrderEntry.class); - - if (WorkspaceFileIndexEx.IS_ENABLED) { - assertExcluded(myExcludedLibSrcDir, myModule); - assertExcluded(myExcludedLibClsDir, myModule); - } - else { - checkInfo(myExcludedLibSrcDir, null, true, false, "lib.src.exc", null, null, myModule3, myModule); - checkInfo(myExcludedLibClsDir, null, true, false, "lib.cls.exc", null, null, myModule3); - } - } - public void testFileContentRootsModifications() { assertNotInProject(myRootVFile); VirtualFile temp = createChildDirectory(myRootVFile, "temp"); @@ -397,54 +261,6 @@ public class DirectoryIndexTest extends DirectoryIndexTestCase { assertTrue(myFileIndex.isInSource(fileSourceRoot)); } - //everything except order entry checks is covered by ModuleRootsInProjectFileIndexTest - public void testSourceContentRootsUnderExcludedRoot() { - VirtualFile contentRoot = createChildDirectory(myExcludeDir, "content"); - PsiTestUtil.addContentRoot(myModule2, contentRoot); - checkInfo(contentRoot, myModule2, false, false, null, null, null, myModule2, myModule3); - VirtualFile excludedFile = createChildData(myExcludeDir, "excluded.txt"); - - VirtualFile sourceRoot = createChildDirectory(myExcludeDir, "src"); - VirtualFile sourceFile = createChildData(sourceRoot, "source.txt"); - SourceFolder sourceFolder = PsiTestUtil.addSourceRoot(myModule2, sourceRoot); - assertEquals(myModule2Dir, assertInProject(sourceRoot).getContentRoot()); - checkInfo(sourceRoot, myModule2, false, false, "", sourceFolder, JavaSourceRootType.SOURCE, myModule2, myModule3); - - VirtualFile contentSourceRoot = createChildDirectory(myExcludeDir, "content-src"); - VirtualFile contentSourceFile = createChildData(sourceRoot, "content-source.txt"); - SourceFolder contentSourceFolder = PsiTestUtil.addSourceContentToRoots(myModule2, contentSourceRoot); - checkInfo(contentSourceRoot, myModule2, false, false, "", contentSourceFolder, JavaSourceRootType.SOURCE, myModule2, myModule3); - - assertIteratedContent(myModule2, - Arrays.asList(sourceFile, contentSourceFile, sourceRoot, contentSourceRoot), - Arrays.asList(excludedFile, myExcludeDir)); - } - - //everything except order entry checks is covered by ModuleRootsInProjectFileIndexTest - public void testSourceContentRootsUnderExcludedRootUnderSourceRoot() { - VirtualFile excluded = createChildDirectory(myModule2Dir, "excluded"); - PsiTestUtil.addExcludedRoot(myModule2, excluded); - VirtualFile excludedFile = createChildData(excluded, "excluded.txt"); - - VirtualFile contentRoot = createChildDirectory(excluded, "content"); - PsiTestUtil.addContentRoot(myModule2, contentRoot); - checkInfo(contentRoot, myModule2, false, false, null, null, null); - - VirtualFile sourceRoot = createChildDirectory(excluded, "src"); - SourceFolder sourceFolder = PsiTestUtil.addSourceRoot(myModule2, sourceRoot); - VirtualFile sourceFile = createChildData(sourceRoot, "source.txt"); - assertEquals(myModule2Dir, assertInProject(sourceRoot).getContentRoot()); - checkInfo(sourceRoot, myModule2, false, false, "", sourceFolder, JavaSourceRootType.SOURCE, myModule2, myModule3); - - VirtualFile contentSourceRoot = createChildDirectory(excluded, "content-src"); - VirtualFile contentSourceFile = createChildData(contentSourceRoot, "content-source.txt"); - SourceFolder contentSourceFolder = PsiTestUtil.addSourceContentToRoots(myModule2, contentSourceRoot); - checkInfo(contentSourceRoot, myModule2, false, false, "", contentSourceFolder, JavaSourceRootType.SOURCE, myModule2, myModule3); - - assertIteratedContent(myModule2, Arrays.asList(sourceFile, contentSourceFile, sourceRoot, contentSourceRoot), - Arrays.asList(excludedFile, myExcludeDir)); - } - private void checkInfo(VirtualFile file, @Nullable Module module, boolean isInLibraryClasses,