JPS tests: support custom mpp multi module tests, rearrange test data files for more consistency, configure js modules with facet (not with stdlib dependency which should be deprecated), temporary mute some complex mpp tests

Original commit: 1b93f07a76
This commit is contained in:
Sergey Rostov
2018-09-10 13:21:35 +03:00
parent c85464d2ae
commit 461df40078
64 changed files with 335 additions and 1093 deletions
@@ -43,18 +43,21 @@ import org.jetbrains.jps.model.JpsModuleRootModificationUtil
import org.jetbrains.jps.model.java.JpsJavaExtensionService
import org.jetbrains.jps.model.library.sdk.JpsSdk
import org.jetbrains.jps.util.JpsPathUtil
import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
import org.jetbrains.kotlin.cli.common.arguments.K2MetadataCompilerArguments
import org.jetbrains.kotlin.config.IncrementalCompilation
import org.jetbrains.kotlin.incremental.LookupSymbol
import org.jetbrains.kotlin.incremental.storage.version.CacheAttributesDiff
import org.jetbrains.kotlin.incremental.storage.version.CacheVersionManager
import org.jetbrains.kotlin.incremental.testingUtils.*
import org.jetbrains.kotlin.jps.build.dependeciestxt.ModulesTxtBuilder
import org.jetbrains.kotlin.jps.build.dependeciestxt.ModulesTxt
import org.jetbrains.kotlin.jps.build.dependeciestxt.ModulesTxtBuilder
import org.jetbrains.kotlin.jps.incremental.CompositeLookupsCacheAttributesManager
import org.jetbrains.kotlin.jps.incremental.getKotlinCache
import org.jetbrains.kotlin.jps.incremental.withLookupStorage
import org.jetbrains.kotlin.jps.model.JpsKotlinFacetModuleExtension
import org.jetbrains.kotlin.jps.model.kotlinFacet
import org.jetbrains.kotlin.jps.targets.KotlinModuleBuildTarget
import org.jetbrains.kotlin.test.KotlinTestUtils
import org.jetbrains.kotlin.utils.Printer
@@ -301,6 +304,8 @@ abstract class AbstractIncrementalJpsTest(
Disposer.register(testRootDisposable, Disposable { FileUtilRt.delete(workDir) })
val modulesTxt = configureModules()
if (modulesTxt?.muted == true) return
initialMake()
val otherMakeResults = performModificationsAndMake(modulesTxt?.modules?.map { it.name })
@@ -447,11 +452,15 @@ abstract class AbstractIncrementalJpsTest(
if (modulesTxt == null) configureSingleModuleProject(jdk)
else configureMultiModuleProject(modulesTxt, jdk)
addStdlib()
overrideModuleSettings()
configureRequiredLibraries()
return modulesTxt
}
open fun overrideModuleSettings() {
}
private fun configureSingleModuleProject(jdk: JpsSdk<JpsDummyElement>?) {
addModule("module", arrayOf(getAbsolutePath("src")), null, null, jdk)
@@ -513,9 +522,19 @@ abstract class AbstractIncrementalJpsTest(
}
}
protected open fun addStdlib() {
AbstractKotlinJpsBuildTestCase.addKotlinStdlibDependency(myProject)
AbstractKotlinJpsBuildTestCase.addKotlinTestDependency(myProject)
private fun configureRequiredLibraries() {
myProject.modules.forEach { module ->
when (module.kotlinFacet?.settings?.compilerArguments) {
null, is K2JVMCompilerArguments -> {
JpsModuleRootModificationUtil.addDependency(module, requireLibrary(KotlinJpsLibrary.JvmStdLib))
JpsModuleRootModificationUtil.addDependency(module, requireLibrary(KotlinJpsLibrary.JvmTest))
}
is K2JSCompilerArguments -> {
JpsModuleRootModificationUtil.addDependency(module, requireLibrary(KotlinJpsLibrary.JsStdLib))
JpsModuleRootModificationUtil.addDependency(module, requireLibrary(KotlinJpsLibrary.JsTest))
}
}
}
}
protected open fun preProcessSources(srcDir: File) {
@@ -5,29 +5,14 @@
package org.jetbrains.kotlin.jps.build
import org.jetbrains.kotlin.config.IncrementalCompilation
import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
import org.jetbrains.kotlin.config.KotlinFacetSettings
import org.jetbrains.kotlin.incremental.testingUtils.BuildLogFinder
import org.jetbrains.kotlin.incremental.testingUtils.BuildLogFinder.Companion.JS_JPS_LOG
import org.jetbrains.kotlin.jps.model.JpsKotlinFacetModuleExtension
import java.io.File
abstract class AbstractIncrementalJsJpsTest : AbstractIncrementalJpsTest() {
private var isICEnabledForJsBackup: Boolean = false
override fun setUp() {
super.setUp()
isICEnabledForJsBackup = IncrementalCompilation.isEnabledForJs()
IncrementalCompilation.setIsEnabledForJs(true)
}
override fun tearDown() {
IncrementalCompilation.setIsEnabledForJs(isICEnabledForJsBackup)
super.tearDown()
}
override fun addStdlib() {
AbstractKotlinJpsBuildTestCase.addKotlinJavaScriptStdlibDependency(myProject)
}
override val buildLogFinder: BuildLogFinder
get() = super.buildLogFinder.copy(isJsEnabled = true)
@@ -38,4 +23,16 @@ abstract class AbstractIncrementalJsJpsTest : AbstractIncrementalJpsTest() {
}
super.doTest(testDataPath)
}
override fun overrideModuleSettings() {
myProject.modules.forEach {
val facet = KotlinFacetSettings()
facet.compilerArguments = K2JSCompilerArguments()
it.container.setChild(
JpsKotlinFacetModuleExtension.KIND,
JpsKotlinFacetModuleExtension(facet)
)
}
}
}
@@ -1,116 +0,0 @@
/*
* Copyright 2010-2015 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.jps.build;
import com.intellij.openapi.util.io.FileUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.JpsDummyElement;
import org.jetbrains.jps.model.JpsModuleRootModificationUtil;
import org.jetbrains.jps.model.JpsProject;
import org.jetbrains.jps.model.java.JpsJavaDependencyScope;
import org.jetbrains.jps.model.java.JpsJavaLibraryType;
import org.jetbrains.jps.model.java.JpsJavaSdkType;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsOrderRootType;
import org.jetbrains.jps.model.library.JpsTypedLibrary;
import org.jetbrains.jps.model.library.sdk.JpsSdk;
import org.jetbrains.jps.model.module.JpsModule;
import org.jetbrains.jps.util.JpsPathUtil;
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.kotlin.utils.PathUtil;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
public abstract class AbstractKotlinJpsBuildTestCase extends BaseKotlinJpsBuildTestCase {
public static final String TEST_DATA_PATH = "jps-plugin/testData/";
protected File workDir;
protected static File copyTestDataToTmpDir(File testDataDir) throws IOException {
assert testDataDir.exists() : "Cannot find source folder " + testDataDir.getAbsolutePath();
File tmpDir = FileUtil.createTempDirectory("jps-build", null);
FileUtil.copyDir(testDataDir, tmpDir);
return tmpDir;
}
@Override
protected File doGetProjectDir() throws IOException {
return workDir;
}
@Override
protected JpsSdk<JpsDummyElement> addJdk(String name, String path) {
String homePath = System.getProperty("java.home");
String versionString = System.getProperty("java.version");
JpsTypedLibrary<JpsSdk<JpsDummyElement>> jdk = myModel.getGlobal().addSdk(name, homePath, versionString, JpsJavaSdkType.INSTANCE);
jdk.addRoot(JpsPathUtil.pathToUrl(path), JpsOrderRootType.COMPILED);
return jdk.getProperties();
}
protected JpsLibrary addKotlinMockRuntimeDependency() {
return addDependency("kotlin-mock-runtime", ForTestCompileRuntime.minimalRuntimeJarForTests());
}
protected JpsLibrary addKotlinStdlibDependency() {
return addKotlinStdlibDependency(myProject);
}
protected JpsLibrary addKotlinJavaScriptStdlibDependency() {
return addDependency("KotlinJavaScript", PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath());
}
static JpsLibrary addKotlinJavaScriptStdlibDependency(@NotNull JpsProject project) {
return addDependency(project,"KotlinJavaScript", PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath());
}
static JpsLibrary addKotlinStdlibDependency(@NotNull JpsProject project) {
return addKotlinStdlibDependency(project.getModules(), false);
}
static JpsLibrary addKotlinTestDependency(@NotNull JpsProject project) {
return addDependency(project, "kotlin-test", PathUtil.getKotlinPathsForDistDirectory().getKotlinTestPath());
}
protected static JpsLibrary addKotlinStdlibDependency(@NotNull Collection<JpsModule> modules, boolean exported) {
return addDependency(JpsJavaDependencyScope.COMPILE, modules, exported, "kotlin-stdlib",
PathUtil.getKotlinPathsForDistDirectory().getStdlibPath(),
new File(PathUtil.getKotlinPathsForDistDirectory().getLibPath(), "annotations-13.0.jar"));
}
protected JpsLibrary addDependency(@NotNull String libraryName, @NotNull File libraryFile) {
return addDependency(myProject, libraryName, libraryFile);
}
private static JpsLibrary addDependency(@NotNull JpsProject project, @NotNull String libraryName, @NotNull File libraryFile) {
return addDependency(JpsJavaDependencyScope.COMPILE, project.getModules(), false, libraryName, libraryFile);
}
protected static JpsLibrary addDependency(JpsJavaDependencyScope type, Collection<JpsModule> modules, boolean exported, String libraryName, File... file) {
JpsLibrary library = modules.iterator().next().getProject().addLibrary(libraryName, JpsJavaLibraryType.INSTANCE);
for (File fileRoot : file) {
library.addRoot(fileRoot, JpsOrderRootType.COMPILED);
}
for (JpsModule module : modules) {
JpsModuleRootModificationUtil.addDependency(module, library, type, exported);
}
return library;
}
}
@@ -0,0 +1,122 @@
/*
* Copyright 2010-2015 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.jps.build
import com.intellij.openapi.util.io.FileUtil
import org.jetbrains.jps.model.JpsDummyElement
import org.jetbrains.jps.model.JpsModuleRootModificationUtil
import org.jetbrains.jps.model.JpsProject
import org.jetbrains.jps.model.java.JpsJavaDependencyScope
import org.jetbrains.jps.model.java.JpsJavaLibraryType
import org.jetbrains.jps.model.java.JpsJavaSdkType
import org.jetbrains.jps.model.library.JpsLibrary
import org.jetbrains.jps.model.library.JpsOrderRootType
import org.jetbrains.jps.model.library.sdk.JpsSdk
import org.jetbrains.jps.model.module.JpsModule
import org.jetbrains.jps.util.JpsPathUtil
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
import org.jetbrains.kotlin.utils.PathUtil
import java.io.File
import java.io.IOException
abstract class AbstractKotlinJpsBuildTestCase : BaseKotlinJpsBuildTestCase() {
protected lateinit var workDir: File
@Throws(IOException::class)
override fun doGetProjectDir(): File? {
return workDir
}
override fun addJdk(name: String, path: String?): JpsSdk<JpsDummyElement> {
val homePath = System.getProperty("java.home")
val versionString = System.getProperty("java.version")
val jdk = myModel.global.addSdk(name, homePath, versionString, JpsJavaSdkType.INSTANCE)
jdk.addRoot(JpsPathUtil.pathToUrl(path), JpsOrderRootType.COMPILED)
return jdk.properties
}
protected fun addKotlinMockRuntimeDependency(): JpsLibrary {
return addDependency("kotlin-mock-runtime", ForTestCompileRuntime.minimalRuntimeJarForTests())
}
protected fun addKotlinStdlibDependency(): JpsLibrary {
return addKotlinStdlibDependency(myProject)
}
protected fun addKotlinJavaScriptStdlibDependency(): JpsLibrary {
return addDependency("KotlinJavaScript", PathUtil.kotlinPathsForDistDirectory.jsStdLibJarPath)
}
protected fun addDependency(libraryName: String, libraryFile: File): JpsLibrary {
return addDependency(myProject, libraryName, libraryFile)
}
companion object {
val TEST_DATA_PATH = "jps-plugin/testData/"
@Throws(IOException::class)
@JvmStatic
protected fun copyTestDataToTmpDir(testDataDir: File): File {
assert(testDataDir.exists()) { "Cannot find source folder " + testDataDir.absolutePath }
val tmpDir = FileUtil.createTempDirectory("jps-build", null)
FileUtil.copyDir(testDataDir, tmpDir)
return tmpDir
}
@JvmStatic
internal fun addKotlinStdlibDependency(project: JpsProject): JpsLibrary {
return addKotlinStdlibDependency(project.modules, false)
}
@JvmStatic
protected fun addKotlinStdlibDependency(modules: Collection<JpsModule>, exported: Boolean): JpsLibrary {
return addDependency(
JpsJavaDependencyScope.COMPILE,
modules,
exported,
"kotlin-stdlib",
PathUtil.kotlinPathsForDistDirectory.stdlibPath
)
}
@JvmStatic
private fun addDependency(project: JpsProject, libraryName: String, libraryFile: File): JpsLibrary {
return addDependency(JpsJavaDependencyScope.COMPILE, project.modules, false, libraryName, libraryFile)
}
@JvmStatic
protected fun addDependency(
type: JpsJavaDependencyScope,
modules: Collection<JpsModule>,
exported: Boolean,
libraryName: String,
vararg file: File
): JpsLibrary {
val library = modules.iterator().next().project.addLibrary(libraryName, JpsJavaLibraryType.INSTANCE)
for (fileRoot in file) {
library.addRoot(fileRoot, JpsOrderRootType.COMPILED)
}
for (module in modules) {
JpsModuleRootModificationUtil.addDependency(module, library, type, exported)
}
return library
}
}
}
@@ -9,12 +9,12 @@ import org.jetbrains.kotlin.jps.build.dependeciestxt.ModulesTxt
import org.jetbrains.kotlin.jps.build.dependeciestxt.MppJpsIncTestsGenerator
import java.io.File
abstract class AbstractMultiplatformJpsTest : AbstractIncrementalJpsTest() {
abstract class AbstractMultiplatformJpsTestWithGeneratedContent : AbstractIncrementalJpsTest() {
override val modulesTxtFile: File
get() = File(testDataDir.parent, "dependencies.txt").also {
check(it.exists()) {
"`dependencies.txt` should be in parent dir. " +
"See jps-plugin/testData/incremental/multiplatform/multiModule/README.md for details"
"See `jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/README.md` for details"
}
}
@@ -27,7 +27,8 @@ abstract class AbstractMultiplatformJpsTest : AbstractIncrementalJpsTest() {
val testCaseName = testDataDir.name
val generator = MppJpsIncTestsGenerator(modulesTxt) { testDataSrc }
val testCase = generator.testCases.find { it.name == testCaseName } ?: error("Unsupported test case name: $testCaseName")
val testCase = generator.testCases.find { it.name == testCaseName }
?: error("Test case `$testCaseName` is not configured in ${modulesTxt.fileName}")
testCase.generate()
}
@@ -17,6 +17,7 @@
package org.jetbrains.kotlin.jps.build
import org.jetbrains.jps.builders.JpsBuildTestCase
import org.jetbrains.jps.model.library.JpsLibrary
abstract class BaseKotlinJpsBuildTestCase : JpsBuildTestCase() {
@Throws(Exception::class)
@@ -32,4 +33,10 @@ abstract class BaseKotlinJpsBuildTestCase : JpsBuildTestCase() {
myModel = null
myBuildParams.clear()
}
private val libraries = mutableMapOf<String, JpsLibrary>()
protected fun requireLibrary(library: KotlinJpsLibrary) = libraries.getOrPut(library.id) {
library.create(myProject)
}
}
@@ -567,6 +567,19 @@ public class IncrementalJpsTestGenerated extends AbstractIncrementalJpsTest {
}
}
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/custom")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class Custom extends AbstractIncrementalJpsTest {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInCustom() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/pureKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
@@ -0,0 +1,34 @@
/*
* Copyright 2010-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/LICENSE.txt file.
*/
package org.jetbrains.kotlin.jps.build
import org.jetbrains.jps.model.JpsProject
import org.jetbrains.jps.model.java.JpsJavaLibraryType
import org.jetbrains.jps.model.library.JpsLibrary
import org.jetbrains.jps.model.library.JpsOrderRootType
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
import org.jetbrains.kotlin.utils.PathUtil
import java.io.File
enum class KotlinJpsLibrary(val id: String, private vararg val roots: File) {
MockRuntime("kotlin-mock-runtime", ForTestCompileRuntime.minimalRuntimeJarForTests()),
JvmStdLib("kotlin-stdlib", PathUtil.kotlinPathsForDistDirectory.stdlibPath),
JvmTest("kotlin-test", PathUtil.kotlinPathsForDistDirectory.kotlinTestPath),
JsStdLib("KotlinJavaScript", PathUtil.kotlinPathsForDistDirectory.jsStdLibJarPath),
JsTest("KotlinJavaScriptTest", PathUtil.kotlinPathsForDistDirectory.jsKotlinTestJarPath);
fun create(project: JpsProject): JpsLibrary {
val library = project.addLibrary(id, JpsJavaLibraryType.INSTANCE)
for (fileRoot in roots) {
library.addRoot(fileRoot, JpsOrderRootType.COMPILED)
}
return library
}
}
@@ -17,426 +17,408 @@ import java.util.regex.Pattern;
/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
@SuppressWarnings("all")
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public class MultiplatformJpsTestGenerated extends AbstractMultiplatformJpsTest {
public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInMultiplatformMultiModule() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simple")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class Simple extends AbstractMultiplatformJpsTest {
public static class Simple extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInSimple() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simple"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
@TestMetadata("editingCExpectActual")
public void testEditingCExpectActual() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingCExpectActual/");
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
@TestMetadata("editingCKotlin")
public void testEditingCKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingCKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingCKotlin/");
}
@TestMetadata("editingPJsKotlin")
public void testEditingPJsKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJsKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJsKotlin/");
}
@TestMetadata("editingPJvmJava")
public void testEditingPJvmJava() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJvmJava/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmJava/");
}
@TestMetadata("editingPJvmKotlin")
public void testEditingPJvmKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJvmKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmKotlin/");
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingCExpectActual")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingCKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingCExpectActual extends AbstractMultiplatformJpsTest {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingCExpectActual() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingCExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingCKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingCKotlin extends AbstractMultiplatformJpsTest {
public static class EditingCKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingCKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJsKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJsKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingPJsKotlin extends AbstractMultiplatformJpsTest {
public static class EditingPJsKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingPJsKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJsKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJsKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJvmJava")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmJava")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingPJvmJava extends AbstractMultiplatformJpsTest {
public static class EditingPJvmJava extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingPJvmJava() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJvmJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJvmKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingPJvmKotlin extends AbstractMultiplatformJpsTest {
public static class EditingPJvmKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingPJvmKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simple/editingPJvmKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simpleJsJvmProjectWithTests")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class SimpleJsJvmProjectWithTests extends AbstractMultiplatformJpsTest {
public static class SimpleJsJvmProjectWithTests extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInSimpleJsJvmProjectWithTests() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simpleJsJvmProjectWithTests"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
@TestMetadata("editingCMainExpectActual")
public void testEditingCMainExpectActual() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simpleJsJvmProjectWithTests/editingCMainExpectActual/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCMainExpectActual/");
}
@TestMetadata("editingCTestsExpectActual")
public void testEditingCTestsExpectActual() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simpleJsJvmProjectWithTests/editingCTestsExpectActual/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCTestsExpectActual/");
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simpleJsJvmProjectWithTests/editingCMainExpectActual")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCMainExpectActual")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingCMainExpectActual extends AbstractMultiplatformJpsTest {
public static class EditingCMainExpectActual extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingCMainExpectActual() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simpleJsJvmProjectWithTests/editingCMainExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCMainExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simpleJsJvmProjectWithTests/editingCTestsExpectActual")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCTestsExpectActual")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingCTestsExpectActual extends AbstractMultiplatformJpsTest {
public static class EditingCTestsExpectActual extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingCTestsExpectActual() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simpleJsJvmProjectWithTests/editingCTestsExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCTestsExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class SimpleNewMpp extends AbstractMultiplatformJpsTest {
public static class SimpleNewMpp extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInSimpleNewMpp() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
@TestMetadata("editingCKotlin")
public void testEditingCKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingCKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingCKotlin/");
}
@TestMetadata("editingPJsKotlin")
public void testEditingPJsKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJsKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJsKotlin/");
}
@TestMetadata("editingPJvmJava")
public void testEditingPJvmJava() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJvmJava/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmJava/");
}
@TestMetadata("editingPJvmKotlin")
public void testEditingPJvmKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJvmKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmKotlin/");
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingCKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingCKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingCKotlin extends AbstractMultiplatformJpsTest {
public static class EditingCKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingCKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJsKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJsKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingPJsKotlin extends AbstractMultiplatformJpsTest {
public static class EditingPJsKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingPJsKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJsKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJsKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJvmJava")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmJava")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingPJvmJava extends AbstractMultiplatformJpsTest {
public static class EditingPJvmJava extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingPJvmJava() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJvmJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJvmKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingPJvmKotlin extends AbstractMultiplatformJpsTest {
public static class EditingPJvmKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingPJvmKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/simpleNewMpp/editingPJvmKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class Ultimate extends AbstractMultiplatformJpsTest {
public static class Ultimate extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInUltimate() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
@TestMetadata("editingACommonExpectActual")
public void testEditingACommonExpectActual() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingACommonExpectActual/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingACommonExpectActual/");
}
@TestMetadata("editingAJsClientKotlin")
public void testEditingAJsClientKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJsClientKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJsClientKotlin/");
}
@TestMetadata("editingAJvmClientJava")
public void testEditingAJvmClientJava() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJvmClientJava/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientJava/");
}
@TestMetadata("editingAJvmClientKotlin")
public void testEditingAJvmClientKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJvmClientKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientKotlin/");
}
@TestMetadata("editingBCommonExpectActual")
public void testEditingBCommonExpectActual() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingBCommonExpectActual/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingBCommonExpectActual/");
}
@TestMetadata("editingRJsKotlin")
public void testEditingRJsKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRJsKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJsKotlin/");
}
@TestMetadata("editingRJvmKotlin")
public void testEditingRJvmKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRJvmKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJvmKotlin/");
}
@TestMetadata("editingRaJsKotlin")
public void testEditingRaJsKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRaJsKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJsKotlin/");
}
@TestMetadata("editingRaJvmKotlin")
public void testEditingRaJvmKotlin() throws Exception {
runTest("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRaJvmKotlin/");
runTest("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJvmKotlin/");
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingACommonExpectActual")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingACommonExpectActual")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingACommonExpectActual extends AbstractMultiplatformJpsTest {
public static class EditingACommonExpectActual extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingACommonExpectActual() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingACommonExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingACommonExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJsClientKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJsClientKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingAJsClientKotlin extends AbstractMultiplatformJpsTest {
public static class EditingAJsClientKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingAJsClientKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJsClientKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJsClientKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJvmClientJava")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientJava")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingAJvmClientJava extends AbstractMultiplatformJpsTest {
public static class EditingAJvmClientJava extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingAJvmClientJava() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJvmClientJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJvmClientKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingAJvmClientKotlin extends AbstractMultiplatformJpsTest {
public static class EditingAJvmClientKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingAJvmClientKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingAJvmClientKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingBCommonExpectActual")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingBCommonExpectActual")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingBCommonExpectActual extends AbstractMultiplatformJpsTest {
public static class EditingBCommonExpectActual extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingBCommonExpectActual() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingBCommonExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingBCommonExpectActual"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRJsKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJsKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingRJsKotlin extends AbstractMultiplatformJpsTest {
public static class EditingRJsKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingRJsKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRJsKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJsKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRJvmKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJvmKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingRJvmKotlin extends AbstractMultiplatformJpsTest {
public static class EditingRJvmKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingRJvmKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRJvmKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJvmKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRaJsKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJsKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingRaJsKotlin extends AbstractMultiplatformJpsTest {
public static class EditingRaJsKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingRaJsKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRaJsKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJsKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
@TestMetadata("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRaJvmKotlin")
@TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJvmKotlin")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class EditingRaJvmKotlin extends AbstractMultiplatformJpsTest {
public static class EditingRaJvmKotlin extends AbstractMultiplatformJpsTestWithGeneratedContent {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
}
public void testAllFilesPresentInEditingRaJvmKotlin() throws Exception {
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiplatform/multiModule/ultimate/editingRaJvmKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJvmKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
}
}
}
@@ -27,6 +27,7 @@ import kotlin.reflect.full.memberProperties
* See [README.md] for more details.
*/
data class ModulesTxt(
val muted: Boolean,
val file: File,
val fileName: String,
val modules: List<Module>,
@@ -107,6 +108,8 @@ data class ModulesTxt(
}
class ModulesTxtBuilder {
var muted = false
val modules = mutableMapOf<String, ModuleRef>()
private val dependencies = mutableListOf<DependencyBuilder>()
@@ -173,7 +176,7 @@ class ModulesTxtBuilder {
val dependencies = dependencies.map { it.build() }
val modules = modules.values.mapIndexed { index, moduleRef -> moduleRef.build(index) }
return ModulesTxt(file, fileTitle, modules, dependencies)
return ModulesTxt(muted, file, fileTitle, modules, dependencies)
}
private fun parseDeclaration(line: String) = doParseDeclaration(removeComments(line))
@@ -183,6 +186,9 @@ class ModulesTxtBuilder {
private fun doParseDeclaration(line: String) {
when {
line.isEmpty() -> Unit // skip empty lines
line == "MUTED" -> {
muted = true
}
line.contains("->") -> {
val (from, rest) = line.split("->", limit = 2)
if (rest.isBlank()) {
@@ -11,7 +11,12 @@ import java.io.File
* Utility for generating common/platform module stub contents based on it's dependencies.
*/
fun actualizeMppJpsIncTestCaseDirs(rootDir: String, dir: String) {
File("$rootDir/$dir").listFiles { it: File -> it.isDirectory }.forEach { dirFile ->
val rootDirFile = File("$rootDir/$dir")
check(rootDirFile.isDirectory) { "`$rootDirFile` is not a directory" }
rootDirFile.listFiles { it: File -> it.isDirectory }.forEach { dirFile ->
check(dirFile.isDirectory) { "`$dirFile` is not a directory" }
val dependenciesTxtFile = File(dirFile, "dependencies.txt")
if (dependenciesTxtFile.exists()) {
val fileTitle = "$dir/${dirFile.name}/dependencies.txt"
@@ -0,0 +1 @@
Multi module tests that run on every platform (currently JVM and JS).
@@ -0,0 +1 @@
Multiplatform multi module tests with custom content.
@@ -1,4 +1,4 @@
Multiplatform multi module tests.
Multiplatform multi module tests with generated content.
This tests is autogenerated based on dependencies.txt by `MppJpsIncTestsGenerator`.
@@ -1,4 +1,5 @@
c [common, edit, editExpectActual]
// TODO: editExpectActual
c [common, edit]
pJvm [jvm, edit, editJvm]
pJvm -> c [expectedBy]
@@ -1,4 +1,5 @@
c [sourceSetHolder, edit, editExpectActual]
// TODO: editExpectActual
c [sourceSetHolder, edit]
pJvm [compilationAndSourceSetHolder, jvm, edit, editJvm]
pJvm -> c [include]
@@ -1,213 +0,0 @@
================ Step #1 create new service in c =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Compiling files:
c/src/serviceCNewHeader.kt
End of files
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[pJs] Expected function 'c_platformDependentCNew' has no actual declaration in module
================ Step #2 create new service in pJvm =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Compiling files:
c/src/serviceCNewHeader.kt
End of files
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[pJs] Expected function 'c_platformDependentCNew' has no actual declaration in module
================ Step #3 create new service in pJs =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Compiling files:
c/src/serviceCNewHeader.kt
pJs/src/servicePJsNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Building pJvm
Compiling files:
c/src/serviceCNewHeader.kt
pJvm/src/servicePJvmNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Compiling files:
pJvm/src/PJvmNewJavaClass.java
End of files
Cleaning output files:
out/production/pJvm/META-INF/pJvm.kotlin_module
out/production/pJvm/ServicePJvmNewImplKt.class
End of files
Compiling files:
c/src/serviceCNewHeader.kt
pJvm/src/servicePJvmNewImpl.kt
End of files
Exit code: OK
------------------------------------------
================ Step #4 change new service in c =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Cleaning output files:
out/production/pJs/pJs.js
out/production/pJs/pJs.meta.js
out/production/pJs/pJs/root-package.kjsm
End of files
Compiling files:
c/src/serviceCNewHeader.kt
pJs/src/servicePJsNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Building pJvm
Cleaning output files:
out/production/pJvm/META-INF/pJvm.kotlin_module
out/production/pJvm/ServiceCNewHeaderKt.class
End of files
Compiling files:
c/src/serviceCNewHeader.kt
pJvm/src/servicePJvmNewImpl.kt
End of files
Exit code: OK
------------------------------------------
================ Step #5 change new service in pJvm: java =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Exit code: NOTHING_DONE
------------------------------------------
Building pJvm
Cleaning output files:
out/production/pJvm/META-INF/pJvm.kotlin_module
out/production/pJvm/PJvmNewJavaClass.class
out/production/pJvm/ServiceCNewHeaderKt.class
End of files
Compiling files:
c/src/serviceCNewHeader.kt
pJvm/src/servicePJvmNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Compiling files:
pJvm/src/PJvmNewJavaClass.java
End of files
================ Step #6 change new service in pJvm: kotlin =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Exit code: NOTHING_DONE
------------------------------------------
Building pJvm
Cleaning output files:
out/production/pJvm/META-INF/pJvm.kotlin_module
out/production/pJvm/ServicePJvmNewImplKt.class
End of files
Compiling files:
c/src/serviceCNewHeader.kt
pJvm/src/servicePJvmNewImpl.kt
End of files
Exit code: OK
------------------------------------------
================ Step #7 change new service in pJs =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Cleaning output files:
out/production/pJs/pJs.js
out/production/pJs/pJs.meta.js
out/production/pJs/pJs/root-package.kjsm
End of files
Compiling files:
c/src/serviceCNewHeader.kt
pJs/src/servicePJsNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Building pJvm
Exit code: NOTHING_DONE
------------------------------------------
================ Step #8 delete new service in pJvm =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Exit code: NOTHING_DONE
------------------------------------------
Cleaning output files:
out/production/pJvm/META-INF/pJvm.kotlin_module
out/production/pJvm/ServicePJvmNewImplKt.class
End of files
Building pJvm
Compiling files:
c/src/serviceCNewHeader.kt
End of files
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[pJvm] Expected function 'c_platformDependentCNew' has no actual declaration in module
================ Step #9 delete new service in pJs =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Cleaning output files:
out/production/pJs/pJs.js
out/production/pJs/pJs.meta.js
out/production/pJs/pJs/root-package.kjsm
End of files
Building pJs
Compiling files:
c/src/serviceCNewHeader.kt
End of files
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[pJs] Expected function 'c_platformDependentCNew' has no actual declaration in module
================ Step #10 delete new service in c =================
Building c
Exit code: NOTHING_DONE
------------------------------------------
Building pJs
Compiling files:
End of files
Exit code: OK
------------------------------------------
Cleaning output files:
out/production/pJvm/ServiceCNewHeaderKt.class
End of files
Building pJvm
Compiling files:
End of files
Exit code: OK
------------------------------------------
@@ -1,278 +0,0 @@
================ Step #1 create new service in cMain =================
Building cMain
Building pJsMain
Compiling files:
cMain/src/serviceCMainNewHeader.kt
End of files
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[Module 'pJsMain' production] Expected function 'cMain_platformDependentCMainNew' has no actual declaration in module
================ Step #2 create new service in pJvmMain =================
Building cMain
Building pJsMain
Compiling files:
cMain/src/serviceCMainNewHeader.kt
End of files
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[Module 'pJsMain' production] Expected function 'cMain_platformDependentCMainNew' has no actual declaration in module
================ Step #3 create new service in pJsMain =================
Building cMain
Building pJsMain
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJsMain/src/servicePJsMainNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Building pJvmMain
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJvmMain/src/servicePJvmMainNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Compiling files:
pJvmMain/src/PJvmMainNewJavaClass.java
End of files
Cleaning output files:
out/production/pJvmMain/META-INF/pJvmMain.kotlin_module
out/production/pJvmMain/ServicePJvmMainNewImplKt.class
End of files
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJvmMain/src/servicePJvmMainNewImpl.kt
End of files
Marked as dirty by Kotlin:
cMain/src/serviceCMainNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Exit code: NOTHING_DONE
------------------------------------------
================ Step #4 change new service in cMain =================
Building cMain
Building pJsMain
Cleaning output files:
out/production/pJsMain/pJsMain.js
out/production/pJsMain/pJsMain.meta.js
out/production/pJsMain/pJsMain/root-package.kjsm
End of files
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJsMain/src/servicePJsMainNewImpl.kt
End of files
Marked as dirty by Kotlin:
pJsMain/src/servicePJsMainNewImpl.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Cleaning output files:
out/production/pJsMain/pJsMain.js
out/production/pJsMain/pJsMain.meta.js
out/production/pJsMain/pJsMain/root-package.kjsm
End of files
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJsMain/src/servicePJsMainNewImpl.kt
End of files
Marked as dirty by Kotlin:
cMain/src/serviceCMainNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Cleaning output files:
out/production/pJvmMain/META-INF/pJvmMain.kotlin_module
out/production/pJvmMain/ServiceCMainNewHeaderKt.class
End of files
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJvmMain/src/servicePJvmMainNewImpl.kt
End of files
Marked as dirty by Kotlin:
pJvmMain/src/servicePJvmMainNewImpl.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Cleaning output files:
out/production/pJvmMain/META-INF/pJvmMain.kotlin_module
out/production/pJvmMain/ServicePJvmMainNewImplKt.class
End of files
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJvmMain/src/servicePJvmMainNewImpl.kt
End of files
Marked as dirty by Kotlin:
cMain/src/serviceCMainNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Exit code: NOTHING_DONE
------------------------------------------
================ Step #5 change new service in pJvmMain: java =================
Building cMain
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Cleaning output files:
out/production/pJvmMain/PJvmMainNewJavaClass.class
End of files
Exit code: NOTHING_DONE
------------------------------------------
Compiling files:
pJvmMain/src/PJvmMainNewJavaClass.java
End of files
Building cTests
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Exit code: NOTHING_DONE
------------------------------------------
================ Step #6 change new service in pJvmMain: kotlin =================
Building cMain
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Cleaning output files:
out/production/pJvmMain/META-INF/pJvmMain.kotlin_module
out/production/pJvmMain/ServicePJvmMainNewImplKt.class
End of files
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJvmMain/src/servicePJvmMainNewImpl.kt
End of files
Marked as dirty by Kotlin:
cMain/src/serviceCMainNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Exit code: NOTHING_DONE
------------------------------------------
================ Step #7 change new service in pJsMain =================
Building cMain
Building pJsMain
Cleaning output files:
out/production/pJsMain/pJsMain.js
out/production/pJsMain/pJsMain.meta.js
out/production/pJsMain/pJsMain/root-package.kjsm
End of files
Compiling files:
cMain/src/serviceCMainNewHeader.kt
pJsMain/src/servicePJsMainNewImpl.kt
End of files
Marked as dirty by Kotlin:
cMain/src/serviceCMainNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Exit code: NOTHING_DONE
------------------------------------------
================ Step #8 delete new service in pJvmMain =================
Building cMain
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Cleaning output files:
out/production/pJvmMain/META-INF/pJvmMain.kotlin_module
out/production/pJvmMain/ServicePJvmMainNewImplKt.class
End of files
Building pJvmMain
Compiling files:
cMain/src/serviceCMainNewHeader.kt
End of files
Marked as dirty by Kotlin:
cMain/src/serviceCMainNewHeader.kt
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[Module 'pJvmMain' production] Expected function 'cMain_platformDependentCMainNew' has no actual declaration in module
================ Step #9 delete new service in pJsMain =================
Building cMain
Cleaning output files:
out/production/pJsMain/pJsMain.js
out/production/pJsMain/pJsMain.meta.js
out/production/pJsMain/pJsMain/root-package.kjsm
End of files
Building pJsMain
Compiling files:
cMain/src/serviceCMainNewHeader.kt
End of files
Marked as dirty by Kotlin:
cMain/src/serviceCMainNewHeader.kt
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[Module 'pJsMain' production] Expected function 'cMain_platformDependentCMainNew' has no actual declaration in module
================ Step #10 delete new service in cMain =================
Building cMain
Building pJsMain
Compiling files:
End of files
Exit code: OK
------------------------------------------
Cleaning output files:
out/production/pJvmMain/ServiceCMainNewHeaderKt.class
End of files
Building pJvmMain
Compiling files:
End of files
Exit code: OK
------------------------------------------
Building cTests
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Exit code: NOTHING_DONE
------------------------------------------
@@ -1,346 +0,0 @@
================ Step #1 create new service in cTests =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
End of files
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[pJsTests] Expected function 'cTests_platformDependentCTestsNew' has no actual declaration in module
================ Step #2 create new service in pJvmTests =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
End of files
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[pJsTests] Expected function 'cTests_platformDependentCTestsNew' has no actual declaration in module
================ Step #3 create new service in pJsTests =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJsTests/src/servicePJsTestsNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Building pJvmTests
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJvmTests/src/servicePJvmTestsNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Compiling files:
pJvmTests/src/PJvmTestsNewJavaClass.java
End of files
Cleaning output files:
out/production/pJvmTests/META-INF/pJvmTests.kotlin_module
out/production/pJvmTests/ServicePJvmTestsNewImplKt.class
End of files
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJvmTests/src/servicePJvmTestsNewImpl.kt
End of files
Exit code: OK
------------------------------------------
================ Step #4 change new service in cTests =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Cleaning output files:
out/production/pJsTests/pJsTests.js
out/production/pJsTests/pJsTests.meta.js
out/production/pJsTests/pJsTests/root-package.kjsm
End of files
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJsTests/src/servicePJsTestsNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Marked as dirty by Kotlin:
pJsTests/src/servicePJsTestsNewImpl.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Cleaning output files:
out/production/pJsTests/pJsTests.js
out/production/pJsTests/pJsTests.meta.js
out/production/pJsTests/pJsTests/root-package.kjsm
End of files
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJsTests/src/servicePJsTestsNewImpl.kt
End of files
Marked as dirty by Kotlin:
cTests/src/serviceCTestsNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Cleaning output files:
out/production/pJvmTests/META-INF/pJvmTests.kotlin_module
out/production/pJvmTests/ServiceCTestsNewHeaderKt.class
End of files
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJvmTests/src/servicePJvmTestsNewImpl.kt
End of files
Marked as dirty by Kotlin:
pJvmTests/src/servicePJvmTestsNewImpl.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Cleaning output files:
out/production/pJvmTests/META-INF/pJvmTests.kotlin_module
out/production/pJvmTests/ServicePJvmTestsNewImplKt.class
End of files
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJvmTests/src/servicePJvmTestsNewImpl.kt
End of files
Marked as dirty by Kotlin:
cTests/src/serviceCTestsNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
================ Step #5 change new service in pJvmTests: java =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Cleaning output files:
out/production/pJvmTests/PJvmTestsNewJavaClass.class
End of files
Exit code: NOTHING_DONE
------------------------------------------
Compiling files:
pJvmTests/src/PJvmTestsNewJavaClass.java
End of files
================ Step #6 change new service in pJvmTests: kotlin =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Cleaning output files:
out/production/pJvmTests/META-INF/pJvmTests.kotlin_module
out/production/pJvmTests/ServicePJvmTestsNewImplKt.class
End of files
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJvmTests/src/servicePJvmTestsNewImpl.kt
End of files
Marked as dirty by Kotlin:
cTests/src/serviceCTestsNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
================ Step #7 change new service in pJsTests =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Cleaning output files:
out/production/pJsTests/pJsTests.js
out/production/pJsTests/pJsTests.meta.js
out/production/pJsTests/pJsTests/root-package.kjsm
End of files
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
pJsTests/src/servicePJsTestsNewImpl.kt
End of files
Exit code: OK
------------------------------------------
Marked as dirty by Kotlin:
cTests/src/serviceCTestsNewHeader.kt
Exit code: ADDITIONAL_PASS_REQUIRED
------------------------------------------
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmTests
Exit code: NOTHING_DONE
------------------------------------------
================ Step #8 delete new service in pJvmTests =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Exit code: NOTHING_DONE
------------------------------------------
Cleaning output files:
out/production/pJvmTests/META-INF/pJvmTests.kotlin_module
out/production/pJvmTests/ServicePJvmTestsNewImplKt.class
End of files
Building pJvmTests
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
End of files
Marked as dirty by Kotlin:
cTests/src/serviceCTestsNewHeader.kt
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[Module 'pJvmTests' production] Expected function 'cTests_platformDependentCTestsNew' has no actual declaration in module
================ Step #9 delete new service in pJsTests =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Cleaning output files:
out/production/pJsTests/pJsTests.js
out/production/pJsTests/pJsTests.meta.js
out/production/pJsTests/pJsTests/root-package.kjsm
End of files
Building pJsTests
Compiling files:
cTests/src/serviceCTestsNewHeader.kt
End of files
Marked as dirty by Kotlin:
cTests/src/serviceCTestsNewHeader.kt
Exit code: ABORT
------------------------------------------
COMPILATION FAILED
[Module 'pJsTests' production] Expected function 'cTests_platformDependentCTestsNew' has no actual declaration in module
================ Step #10 delete new service in cTests =================
Building cMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJsMain
Exit code: NOTHING_DONE
------------------------------------------
Building pJvmMain
Exit code: NOTHING_DONE
------------------------------------------
Building cTests
Exit code: NOTHING_DONE
------------------------------------------
Building pJsTests
Compiling files:
End of files
Exit code: OK
------------------------------------------
Cleaning output files:
out/production/pJvmTests/ServiceCTestsNewHeaderKt.class
End of files
Building pJvmTests
Compiling files:
End of files
Exit code: OK
------------------------------------------
@@ -0,0 +1 @@
Single module tests that run on every platform (currently JVM and JS)