From 36ab3253942e3bd3f0e3ab9f18b301c8603161d7 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Tue, 21 May 2019 17:54:44 +0300 Subject: [PATCH] Abstract FIR modularized tests --- .../kotlin/fir/AbstractModularizedTest.kt | 95 +++++++++++++++++++ .../FirResolveModularizedTotalKotlinTest.kt | 86 ++--------------- ...NonFirResolveModularizedTotalKotlinTest.kt | 88 ++--------------- 3 files changed, 112 insertions(+), 157 deletions(-) create mode 100644 compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/AbstractModularizedTest.kt diff --git a/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/AbstractModularizedTest.kt b/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/AbstractModularizedTest.kt new file mode 100644 index 00000000000..95eacbff39b --- /dev/null +++ b/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/AbstractModularizedTest.kt @@ -0,0 +1,95 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir + +import org.jetbrains.kotlin.fir.scopes.ProcessorAction +import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.w3c.dom.Node +import org.w3c.dom.NodeList +import java.io.File +import javax.xml.parsers.DocumentBuilderFactory + +data class ModuleData( + val name: String, + val qualifiedName: String, + val classpath: List, + val sources: List, + val javaSourceRoots: List +) + +private fun NodeList.toList(): List { + val list = mutableListOf() + for (index in 0 until this.length) { + list += item(index) + } + return list +} + + +private val Node.childNodesList get() = childNodes.toList() + +abstract class AbstractModularizedTest : KtUsefulTestCase() { + private fun loadModule(file: File): ModuleData { + + val factory = DocumentBuilderFactory.newInstance() + factory.isIgnoringComments = true + factory.isIgnoringElementContentWhitespace = true + val builder = factory.newDocumentBuilder() + val document = builder.parse(file) + val moduleElement = document.childNodes.item(0).childNodesList.first { it.nodeType == Node.ELEMENT_NODE } + val moduleName = moduleElement.attributes.getNamedItem("name").nodeValue + val outputDir = moduleElement.attributes.getNamedItem("outputDir").nodeValue + val qualifiedModuleName = outputDir.substringAfterLast("/") + val javaSourceRoots = mutableListOf() + val classpath = mutableListOf() + val sources = mutableListOf() + + for (index in 0 until moduleElement.childNodes.length) { + val item = moduleElement.childNodes.item(index) + + if (item.nodeName == "classpath") { + val path = item.attributes.getNamedItem("path").nodeValue + if (path != outputDir) { + classpath += File(path) + } + } + if (item.nodeName == "javaSourceRoots") { + javaSourceRoots += File(item.attributes.getNamedItem("path").nodeValue) + } + if (item.nodeName == "sources") { + sources += File(item.attributes.getNamedItem("path").nodeValue) + } + } + + return ModuleData(moduleName, qualifiedModuleName, classpath, sources, javaSourceRoots) + } + + + protected abstract fun beforePass() + protected abstract fun afterPass() + protected abstract fun processModule(moduleData: ModuleData): ProcessorAction + + protected fun runTestOnce(pass: Int) { + beforePass() + val testDataPath = "/Users/jetbrains/jps" + val root = File(testDataPath) + + println("BASE PATH: ${root.absolutePath}") + + val modules = + root.listFiles().sortedBy { it.lastModified() }.map { loadModule(it) } + .filter { it.qualifiedName == "kotlin.idea.main" } + + + for (module in modules.progress(step = 0.0) { "Analyzing ${it.qualifiedName}" }) { + if (processModule(module).stop()) { + break + } + } + + afterPass() + } +} \ No newline at end of file diff --git a/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt b/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt index fcd80ba57d1..ba5f6f79c0e 100644 --- a/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt +++ b/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt @@ -21,30 +21,17 @@ import org.jetbrains.kotlin.fir.dump.MultiModuleHtmlFirDump import org.jetbrains.kotlin.fir.resolve.FirProvider import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer +import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind -import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase -import org.w3c.dom.Node -import org.w3c.dom.NodeList import java.io.File import java.io.PrintStream import java.text.SimpleDateFormat import java.util.* -import javax.xml.parsers.DocumentBuilderFactory import kotlin.system.measureNanoTime -private fun NodeList.toList(): List { - val list = mutableListOf() - for (index in 0 until this.length) { - list += item(index) - } - return list -} - -private val Node.childNodesList get() = childNodes.toList() - private const val FAIL_FAST = true private const val DUMP_FIR = true @@ -52,18 +39,9 @@ private const val FIR_DUMP_PATH = "tmp/firDump" private const val FIR_HTML_DUMP_PATH = "tmp/firDump-html" private const val FIR_LOGS_PATH = "tmp/fir-logs" -private data class ModuleData( - val name: String, - val qualifiedName: String, - val classpath: List, - val sources: List, - val javaSourceRoots: List -) - private const val PASSES = 1 -class FirResolveModularizedTotalKotlinTest : KtUsefulTestCase() { - +class FirResolveModularizedTotalKotlinTest : AbstractModularizedTest() { private lateinit var bench: FirResolveBench private lateinit var dump: MultiModuleHtmlFirDump @@ -115,7 +93,7 @@ class FirResolveModularizedTotalKotlinTest : KtUsefulTestCase() { } } - private fun processModule(moduleData: ModuleData) { + override fun processModule(moduleData: ModuleData): ProcessorAction { val configurationKind = ConfigurationKind.ALL val testJdkKind = TestJdkKind.FULL_JDK @@ -138,63 +116,15 @@ class FirResolveModularizedTotalKotlinTest : KtUsefulTestCase() { runAnalysis(moduleData, environment) Disposer.dispose(disposable) + if (bench.hasFiles && FAIL_FAST) return ProcessorAction.STOP + return ProcessorAction.NEXT } - private fun loadModule(file: File): ModuleData { - - val factory = DocumentBuilderFactory.newInstance() - factory.isIgnoringComments = true - factory.isIgnoringElementContentWhitespace = true - val builder = factory.newDocumentBuilder() - val document = builder.parse(file) - val moduleElement = document.childNodes.item(0).childNodesList.first { it.nodeType == Node.ELEMENT_NODE } - val moduleName = moduleElement.attributes.getNamedItem("name").nodeValue - val outputDir = moduleElement.attributes.getNamedItem("outputDir").nodeValue - val qualifiedModuleName = outputDir.substringAfterLast("/") - val javaSourceRoots = mutableListOf() - val classpath = mutableListOf() - val sources = mutableListOf() - - for (index in 0 until moduleElement.childNodes.length) { - val item = moduleElement.childNodes.item(index) - - if (item.nodeName == "classpath") { - val path = item.attributes.getNamedItem("path").nodeValue - if (path != outputDir) { - classpath += File(path) - } - } - if (item.nodeName == "javaSourceRoots") { - javaSourceRoots += File(item.attributes.getNamedItem("path").nodeValue) - } - if (item.nodeName == "sources") { - sources += File(item.attributes.getNamedItem("path").nodeValue) - } - } - - return ModuleData(moduleName, qualifiedModuleName, classpath, sources, javaSourceRoots) - } - - - private fun runTestOnce(pass: Int) { + override fun beforePass() { if (DUMP_FIR) dump = MultiModuleHtmlFirDump(File(FIR_HTML_DUMP_PATH)) - val testDataPath = "/Users/jetbrains/jps" - val root = File(testDataPath) - - println("BASE PATH: ${root.absolutePath}") - - val modules = - root.listFiles().sortedBy { it.lastModified() }.map { loadModule(it) } -// .sortedByDescending { it.name == "idea" } - - - for (module in modules.progress(step = 0.0) { "Analyzing ${it.qualifiedName}" }) { - processModule(module) - if (bench.hasFiles && FAIL_FAST) { - break - } - } + } + override fun afterPass() { bench.report(System.out, errorTypeReports = false) saveReport() diff --git a/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/NonFirResolveModularizedTotalKotlinTest.kt b/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/NonFirResolveModularizedTotalKotlinTest.kt index aa06de8d0a7..8f760578ad8 100644 --- a/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/NonFirResolveModularizedTotalKotlinTest.kt +++ b/compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/NonFirResolveModularizedTotalKotlinTest.kt @@ -15,37 +15,21 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler +import org.jetbrains.kotlin.config.* +import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind -import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase -import org.w3c.dom.Node -import org.w3c.dom.NodeList -import java.io.File -import javax.xml.parsers.DocumentBuilderFactory import kotlin.system.measureNanoTime -private fun NodeList.toList(): List { - val list = mutableListOf() - for (index in 0 until this.length) { - list += item(index) - } - return list -} - -private val Node.childNodesList get() = childNodes.toList() - - -private data class XModuleData(val name: String, val classpath: List, val sources: List, val javaSourceRoots: List) - -class NonFirResolveModularizedTotalKotlinTest : KtUsefulTestCase() { +class NonFirResolveModularizedTotalKotlinTest : AbstractModularizedTest() { private var totalTime = 0L private var files = 0 - private fun runAnalysis(moduleData: XModuleData, environment: KotlinCoreEnvironment) { + private fun runAnalysis(moduleData: ModuleData, environment: KotlinCoreEnvironment) { val project = environment.project val time = measureNanoTime { @@ -58,7 +42,7 @@ class NonFirResolveModularizedTotalKotlinTest : KtUsefulTestCase() { } - private fun processModule(moduleData: XModuleData) { + override fun processModule(moduleData: ModuleData): ProcessorAction { val configurationKind = ConfigurationKind.ALL val testJdkKind = TestJdkKind.FULL_JDK @@ -92,73 +76,19 @@ class NonFirResolveModularizedTotalKotlinTest : KtUsefulTestCase() { }) val environment = KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) -// Extensions.getArea(environment.project) -// .getExtensionPoint(PsiElementFinder.EP_NAME) -// .unregisterExtension(JavaElementFinder::class.java) - - println("Processing module: ${moduleData.name}") runAnalysis(moduleData, environment) Disposer.dispose(disposable) - } - - private fun loadModule(file: File): XModuleData { - - val factory = DocumentBuilderFactory.newInstance() - factory.isIgnoringComments = true - factory.isIgnoringElementContentWhitespace = true - val builder = factory.newDocumentBuilder() - val document = builder.parse(file) - val moduleElement = document.childNodes.item(0).childNodesList.first { it.nodeType == Node.ELEMENT_NODE } - val moduleName = moduleElement.attributes.getNamedItem("name").nodeValue - val javaSourceRoots = mutableListOf() - val classpath = mutableListOf() - val sources = mutableListOf() - - for (index in 0 until moduleElement.childNodes.length) { - val item = moduleElement.childNodes.item(index) - - if (item.nodeName == "classpath") { - classpath += File(item.attributes.getNamedItem("path").nodeValue) - } - if (item.nodeName == "javaSourceRoots") { - javaSourceRoots += File(item.attributes.getNamedItem("path").nodeValue) - } - if (item.nodeName == "sources") { - sources += File(item.attributes.getNamedItem("path").nodeValue) - } - } - - return XModuleData(moduleName, classpath, sources, javaSourceRoots) + return ProcessorAction.NEXT } - private fun runTestLocal() { - val testDataPath = "/Users/jetbrains/jps" - val root = File(testDataPath) - - println("BASE PATH: ${root.absolutePath}") - - val modules = - root.listFiles().sortedBy { it.lastModified() }.map { loadModule(it) } - - // .sortedBy { !it.sources.any { it.nameWithoutExtension == "KotlinSearchEverywhereClassifier" } } - - - for (module in modules.progress { "Analyzing ${it.name}" }) { - processModule(module) - } - - println("Total time: ${totalTime * 1e-6} ms, ${(totalTime * 1e-6) / files} ms per file") - totalTime = 0 - files = 0 - } + override fun afterPass() {} + override fun beforePass() {} fun testTotalKotlin() { - //Thread.sleep(5000) for (i in 0..2) { - println("Pass $i") - runTestLocal() + runTestOnce(i) } } } \ No newline at end of file