Refactor, extract util in test code

idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractMultiModuleHighlightingTest.kt

@@ -19,22 +19,16 @@ package org.jetbrains.kotlin.idea.caches.resolve
 import com.intellij.openapi.module.Module
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.config.TargetPlatformKind
-import org.jetbrains.kotlin.idea.project.PluginJetFilesProvider
 import org.jetbrains.kotlin.idea.stubs.AbstractMultiHighlightingTest
-import org.junit.Assert
 
 abstract class AbstractMultiModuleHighlightingTest : AbstractMultiHighlightingTest() {
 
-    protected fun checkHighlightingInAllFiles(nameFilter: (fileName: String) -> Boolean = { true }) {
+    protected fun checkHighlightingInAllFiles(
-        var atLeastOneFile = false
+            shouldCheckFile: () -> Boolean = { !file.text.contains("// !CHECK_HIGHLIGHTING") }
-        PluginJetFilesProvider.allFilesInProject(myProject!!).forEach { file ->
+    ) {
-            if (nameFilter(file.name) && !file.text.contains("// !CHECK_HIGHLIGHTING")) {
+        checkFiles(shouldCheckFile) {
-                atLeastOneFile = true
+            checkHighlighting(myEditor, true, false)
-                configureByExistingFile(file.virtualFile!!)
-                checkHighlighting(myEditor, true, false)
-            }
         }
-        Assert.assertTrue(atLeastOneFile)
     }
 
     protected fun doMultiPlatformTest(

idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt

@@ -16,20 +16,18 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
-import com.intellij.openapi.command.WriteCommandAction
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.module.StdModuleTypes
 import com.intellij.openapi.roots.DependencyScope
 import com.intellij.openapi.roots.ModuleRootModificationUtil
-import com.intellij.openapi.roots.OrderRootType
-import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable
 import com.intellij.openapi.roots.libraries.Library
-import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.testFramework.ModuleTestCase
 import com.intellij.testFramework.UsefulTestCase
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
+import org.jetbrains.kotlin.test.util.addDependency
+import org.jetbrains.kotlin.test.util.jarRoot
+import org.jetbrains.kotlin.test.util.projectLibrary
 import org.junit.Assert
-import java.io.File
 
 class IdeaModuleInfoTest : ModuleTestCase() {
 
@@ -304,12 +302,6 @@ class IdeaModuleInfoTest : ModuleTestCase() {
     private val Library.classes: LibraryInfo
         get() = LibraryInfo(project!!, this)
 
-    private fun Module.addDependency(
-            lib: Library,
-            dependencyScope: DependencyScope = DependencyScope.COMPILE,
-            exported: Boolean = false
-    ) = ModuleRootModificationUtil.addDependency(this, lib, dependencyScope, exported)
-
     private fun module(name: String): Module {
         return createModuleFromTestData(createTempDirectory()!!.absolutePath, name, StdModuleTypes.JAVA, false)!!
     }
@@ -330,22 +322,9 @@ class IdeaModuleInfoTest : ModuleTestCase() {
         UsefulTestCase.assertSameElements(this.getDependentModules(), expected.toList())
     }
 
-    private fun projectLibrary(name: String = "lib", vararg roots: File): Library {
+    private fun stdlibCommon(): Library = projectLibrary("kotlin-stdlib-common", ForTestCompileRuntime.stdlibCommonForTests().jarRoot)
-        val libraryTable = ProjectLibraryTable.getInstance(myProject)!!
-        return WriteCommandAction.runWriteCommandAction<Library>(myProject) {
-            libraryTable.createLibrary(name).apply {
-                for (root in roots) {
-                    val model = modifiableModel
-                    model.addRoot(VfsUtil.getUrlForLibraryRoot(root), OrderRootType.CLASSES)
-                    model.commit()
-                }
-            }
-        }!!
-    }
 
-    private fun stdlibCommon(): Library = projectLibrary("kotlin-stdlib-common", ForTestCompileRuntime.stdlibCommonForTests())
+    private fun stdlibJvm(): Library = projectLibrary("kotlin-stdlib", ForTestCompileRuntime.runtimeJarForTests().jarRoot)
 
-    private fun stdlibJvm(): Library = projectLibrary("kotlin-stdlib", ForTestCompileRuntime.runtimeJarForTests())
+    private fun stdlibJs(): Library = projectLibrary("kotlin-stdlib-js", ForTestCompileRuntime.runtimeJarForTests().jarRoot)
-
-    private fun stdlibJs(): Library = projectLibrary("kotlin-stdlib-js", ForTestCompileRuntime.runtimeJarForTests())
 }

idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleHighlightingTest.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.idea.caches.resolve
 import com.intellij.facet.FacetManager
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.roots.DependencyScope
-import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.analyzer.ResolverForModuleComputationTracker
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
@@ -32,16 +31,10 @@ import org.jetbrains.kotlin.idea.facet.KotlinFacetConfiguration
 import org.jetbrains.kotlin.idea.facet.KotlinFacetType
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
-import org.jetbrains.kotlin.test.KotlinTestUtils
 
 open class MultiModuleHighlightingTest : AbstractMultiModuleHighlightingTest() {
     override fun getTestDataPath() = PluginTestCaseBase.getTestDataPathBase() + "/multiModuleHighlighting/"
 
-    override fun setUp() {
-        super.setUp()
-        VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory())
-    }
-
     fun testVisibility() {
         val module1 = module("m1")
         val module2 = module("m2")
@@ -96,7 +89,7 @@ open class MultiModuleHighlightingTest : AbstractMultiModuleHighlightingTest() {
             assertTrue(module2 !in resolversComputed)
             assertTrue(module3 !in resolversComputed)
 
-            checkHighlightingInAllFiles { "m3" in it }
+            checkHighlightingInAllFiles { "m3" in file.name }
 
             assertTrue(module1 in resolversComputed)
             assertTrue(module2 !in resolversComputed)

idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigationWithMultipleLibrariesTest.kt

@@ -18,13 +18,10 @@ package org.jetbrains.kotlin.idea.decompiler.navigation
 
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.module.StdModuleTypes
-import com.intellij.openapi.roots.DependencyScope
-import com.intellij.openapi.roots.ModuleRootModificationUtil
 import com.intellij.openapi.roots.OrderRootType
 import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable
 import com.intellij.openapi.roots.libraries.Library
 import com.intellij.openapi.vfs.LocalFileSystem
-import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiManager
@@ -37,6 +34,9 @@ import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.util.projectStructure.getModuleDir
 import org.jetbrains.kotlin.test.MockLibraryUtil
 import org.jetbrains.kotlin.test.testFramework.runWriteAction
+import org.jetbrains.kotlin.test.util.addDependency
+import org.jetbrains.kotlin.test.util.jarRoot
+import org.jetbrains.kotlin.test.util.projectLibrary
 import org.junit.Assert
 import java.io.File
 
@@ -56,17 +56,8 @@ class NavigationWithMultipleCustomLibrariesTest : AbstractNavigationWithMultiple
         val librarySrc = testDataPath + "libSrc"
 
         val libraryJar = MockLibraryUtil.compileLibraryToJar(librarySrc, libraryName, withSources, false, false)
-        val jarRoot = libraryJar.jarRoot()
+        val jarRoot = libraryJar.jarRoot
-        return runWriteAction {
+        return projectLibrary(libraryName, jarRoot, jarRoot.findChild("src").takeIf { withSources })
-            val library = ProjectLibraryTable.getInstance(project).createLibrary(libraryName)
-            val modifiableModel = library.modifiableModel
-            modifiableModel.addRoot(jarRoot, OrderRootType.CLASSES)
-            if (withSources) {
-                modifiableModel.addRoot(jarRoot.findChild("src")!!, OrderRootType.SOURCES)
-            }
-            modifiableModel.commit()
-            library
-        }
     }
 }
 
@@ -84,14 +75,14 @@ class NavigationWithMultipleRuntimesTest : AbstractNavigationWithMultipleLibrari
 
     override fun createProjectLib(libraryName: String, withSources: Boolean): Library {
         val libraryJar = ForTestCompileRuntime.runtimeJarForTests().copyTo(File(createTempDirectory(), "$libraryName.jar"))
-        val jarUrl = libraryJar.jarRoot()
+        val jarUrl = libraryJar.jarRoot
         return runWriteAction {
             val library = ProjectLibraryTable.getInstance(project).createLibrary(libraryName)
             val modifiableModel = library.modifiableModel
             modifiableModel.addRoot(jarUrl, OrderRootType.CLASSES)
             if (withSources) {
                 val sourcesJar = ForTestCompileRuntime.runtimeSourcesJarForTests().copyTo(File(createTempDirectory(), "$libraryName-sources.jar"))
-                modifiableModel.addRoot(sourcesJar.jarRoot(), OrderRootType.SOURCES)
+                modifiableModel.addRoot(sourcesJar.jarRoot, OrderRootType.SOURCES)
             }
             modifiableModel.commit()
             library
@@ -108,8 +99,8 @@ abstract class AbstractNavigationWithMultipleLibrariesTest : ModuleTestCase() {
         val moduleA = module("moduleA", srcPath)
         val moduleB = module("moduleB", srcPath)
 
-        addDependencyOnProjectLibrary(moduleA, "libA", withSources)
+        moduleA.addDependency(createProjectLib("libA", withSources))
-        addDependencyOnProjectLibrary(moduleB, "libB", withSources)
+        moduleB.addDependency(createProjectLib("libB", withSources))
 
         // navigation code works by providing first matching declaration from indices
         // that's we need to check references in both modules to guard against possibility of code breaking
@@ -120,22 +111,18 @@ abstract class AbstractNavigationWithMultipleLibrariesTest : ModuleTestCase() {
 
     private fun module(name: String, srcPath: String) = createModuleFromTestData(srcPath, name, StdModuleTypes.JAVA, true)!!
 
-    private fun checkReferencesInModule(moduleB: Module, libraryName: String, expectedFileName: String) {
+    private fun checkReferencesInModule(module: Module, libraryName: String, expectedFileName: String) {
-        NavigationChecker.checkAnnotatedCode(findSourceFile(moduleB), File(testDataPath + expectedFileName)) {
+        NavigationChecker.checkAnnotatedCode(findSourceFile(module), File(testDataPath + expectedFileName)) {
             checkLibraryName(it, libraryName)
         }
     }
 
-    private fun findSourceFile(moduleA: Module): PsiFile {
+    private fun findSourceFile(module: Module): PsiFile {
-        val ioFile = File(moduleA.getModuleDir()).listFiles().first()
+        val ioFile = File(module.getModuleDir()).listFiles().first()
         val vFile = LocalFileSystem.getInstance().findFileByIoFile(ioFile)!!
         return PsiManager.getInstance(project).findFile(vFile)!!
     }
 
-    private fun addDependencyOnProjectLibrary(mainModule: Module, libraryName: String, withSources: Boolean) {
-        val library = createProjectLib(libraryName, withSources)
-        ModuleRootModificationUtil.addDependency(mainModule, library, DependencyScope.COMPILE, false)
-    }
 
     abstract fun createProjectLib(libraryName: String, withSources: Boolean): Library
 }
@@ -151,5 +138,3 @@ private fun checkLibraryName(referenceTarget: PsiElement, expectedName: String)
     }
     Assert.assertEquals("Referenced code from unrelated library: ${referenceTarget.text}", expectedName, libraryName)
 }
-
-private fun File.jarRoot() = StandardFileSystems.getJarRootForLocalFile(LocalFileSystem.getInstance().findFileByIoFile(this)!!)!!

idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocSampleTest.kt

@@ -37,11 +37,6 @@ class KDocSampleTest : AbstractMultiModuleTest() {
 
     override fun getTestDataPath() = "${PluginTestCaseBase.getTestDataPathBase()}/kdoc/multiModuleSamples/"
 
-    override fun setUp() {
-        VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory())
-        super.setUp()
-    }
-
     fun testSimple() {
 
         val code = module("code")

idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiHighlightingTest.kt

@@ -58,5 +58,4 @@ abstract class AbstractMultiHighlightingTest : AbstractMultiModuleTest() {
         }
         return infos
     }
-
 }

idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt

@@ -29,21 +29,30 @@ import com.intellij.openapi.roots.ui.configuration.libraryEditor.NewLibraryEdito
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VfsUtil
+import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess
 import com.intellij.testFramework.PsiTestUtil
 import org.jetbrains.kotlin.config.CompilerSettings
 import org.jetbrains.kotlin.config.KotlinFacetSettingsProvider
 import org.jetbrains.kotlin.config.TargetPlatformKind
 import org.jetbrains.kotlin.idea.facet.getOrCreateFacet
 import org.jetbrains.kotlin.idea.facet.initializeIfNeeded
+import org.jetbrains.kotlin.idea.project.PluginJetFilesProvider
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
 import org.jetbrains.kotlin.idea.test.KotlinJdkAndLibraryProjectDescriptor
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.junit.Assert
 import java.io.File
 
 abstract class AbstractMultiModuleTest : DaemonAnalyzerTestCase() {
 
     abstract override fun getTestDataPath(): String
 
+    override fun setUp() {
+        super.setUp()
+        VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory())
+    }
+
     protected fun module(name: String, hasTestRoot: Boolean = false, useFullJdk: Boolean = false): Module {
         val srcDir = testDataPath + "${getTestName(true)}/$name"
         val moduleWithSrcRootSet = createModuleFromTestData(srcDir, name, StdModuleTypes.JAVA, true)!!
@@ -107,4 +116,16 @@ abstract class AbstractMultiModuleTest : DaemonAnalyzerTestCase() {
             additionalArguments += " -Xmulti-platform"
         }
     }
+
+    protected fun checkFiles(shouldCheckFile: () -> Boolean = { true }, check: () -> Unit) {
+        var atLeastOneFile = false
+        PluginJetFilesProvider.allFilesInProject(myProject!!).forEach { file ->
+            configureByExistingFile(file.virtualFile!!)
+            if (shouldCheckFile()) {
+                atLeastOneFile = true
+                check()
+            }
+        }
+        Assert.assertTrue(atLeastOneFile)
+    }
 }

idea/tests/org/jetbrains/kotlin/test/util/ProjectStructureUtils.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.test.util
+
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.roots.DependencyScope
+import com.intellij.openapi.roots.ModuleRootModificationUtil
+import com.intellij.openapi.roots.OrderRootType
+import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable
+import com.intellij.openapi.roots.libraries.Library
+import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.openapi.vfs.StandardFileSystems
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.testFramework.PlatformTestCase
+import org.jetbrains.kotlin.test.testFramework.runWriteAction
+import java.io.File
+
+fun PlatformTestCase.projectLibrary(
+        libraryName: String = "TestLibrary", classesRoot: VirtualFile? = null, sourcesRoot: VirtualFile? = null
+): Library {
+    return runWriteAction {
+        ProjectLibraryTable.getInstance(project).createLibrary(libraryName).also {
+            with (it.modifiableModel) {
+                classesRoot?.let { addRoot(it, OrderRootType.CLASSES) }
+                sourcesRoot?.let { addRoot(it, OrderRootType.SOURCES) }
+                commit()
+            }
+        }
+    }
+}
+
+val File.jarRoot get() = StandardFileSystems.getJarRootForLocalFile(LocalFileSystem.getInstance().findFileByIoFile(this)!!)!!
+
+fun Module.addDependency(
+        library: Library,
+        dependencyScope: DependencyScope = DependencyScope.COMPILE,
+        exported: Boolean = false
+) = ModuleRootModificationUtil.addDependency(this, library, dependencyScope, exported)