Use published :plugin and :runtime artifacts in integration tests

Adopt 0.5.0-SNAPSHOT version for local publications.

Author: Abduqodiri Qurbonzoda

.teamcity/additionalConfiguration.kt

@@ -11,6 +11,9 @@ import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.GradleBuildStep
 import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.gradle
 
 fun Project.additionalConfiguration() {
+    knownBuilds.buildVersion.params {
+        param(versionSuffixParameter, "")
+    }
     platforms.forEach { platform ->
         val gradleBuild = knownBuilds.buildOn(platform).steps.items.single() as GradleBuildStep
         gradleBuild.tasks += " " + "fastBenchmark"

examples/java/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
     dependencies {
-        classpath "org.jetbrains.kotlinx:kotlinx-benchmark-plugin:0.4.8"
+        classpath "org.jetbrains.kotlinx:kotlinx-benchmark-plugin:0.5.0-SNAPSHOT"
     }
 }
 

examples/kotlin-kts/build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
     java
     kotlin("jvm")
     kotlin("plugin.allopen") version "1.8.21"
-    id("org.jetbrains.kotlinx.benchmark") version "0.4.8"
+    id("org.jetbrains.kotlinx.benchmark") version "0.5.0-SNAPSHOT"
 }
 
 sourceSets.all {

examples/kotlin-multiplatform/build.gradle

@@ -5,7 +5,7 @@ import kotlinx.benchmark.gradle.JsBenchmarksExecutor
 plugins {
     id 'org.jetbrains.kotlin.multiplatform'
     id 'org.jetbrains.kotlin.plugin.allopen' version "1.8.21"
-    id 'org.jetbrains.kotlinx.benchmark' version "0.4.8"
+    id 'org.jetbrains.kotlinx.benchmark' version "0.5.0-SNAPSHOT"
 }
 
 // how to apply plugin to a specific source set?

examples/kotlin/build.gradle

@@ -2,7 +2,7 @@ plugins {
     id 'java'
     id 'org.jetbrains.kotlin.jvm'
     id 'org.jetbrains.kotlin.plugin.allopen' version "1.8.21"
-    id 'org.jetbrains.kotlinx.benchmark' version '0.4.8'
+    id 'org.jetbrains.kotlinx.benchmark' version '0.5.0-SNAPSHOT'
 }
 
 

gradle.properties

@@ -1,5 +1,5 @@
 group=org.jetbrains.kotlinx
-version=0.4.8
+version=0.5.0-SNAPSHOT
 
 kotlin_version=1.8.21
 jmhVersion=1.21

integration/build.gradle.kts

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.konan.target.*
-
 plugins {
     kotlin("jvm")
 }
@@ -10,75 +8,21 @@ repositories {
 
 evaluationDependsOn(":kotlinx-benchmark-runtime")
 
-val Gradle.isConfigurationCacheAvailable
-    get() = try {
-        val startParameters = gradle.startParameter
-        startParameters.javaClass.getMethod("isConfigurationCache")
-            .invoke(startParameters) as? Boolean
-    } catch (_: Exception) {
-        null
-    } ?: false
-
-fun Project.getSystemProperty(key: String): String? {
-    return if (gradle.isConfigurationCacheAvailable) {
-        providers.systemProperty(key).forUseAtConfigurationTime().orNull
-    } else {
-        System.getProperty(key)
-    }
-}
-
-val nativeTargetName
-    get() = when {
-        project.getSystemProperty("idea.active") == "true" -> if (HostManager.hostIsMac) "darwin" else "native"
-        HostManager.hostIsLinux -> "linuxX64"
-        HostManager.hostIsMingw -> "mingwX64"
-        HostManager.host == KonanTarget.MACOS_X64 -> "macosX64"
-        HostManager.host == KonanTarget.MACOS_ARM64 -> "macosArm64"
-        else -> error("Unknown host: ${HostManager.host}")
-    }
-
 val runtime get() = project(":kotlinx-benchmark-runtime")
 val plugin get() = gradle.includedBuild("plugin")
 
-val AbstractArchiveTask.archiveFilePath get() = archiveFile.get().asFile.path
-
-fun artifactsTask(artifact: String) = runtime.tasks.getByName<AbstractArchiveTask>("${artifact}Jar")
-fun artifactsTaskNativeKlibs() = runtime.tasks.getByName("compileKotlin${nativeTargetName.capitalize()}")
-
-fun Task.klibs(): String = outputs.files.filter { it.extension == "klib" }.joinToString("\n")
-
-fun IncludedBuild.classpath() = projectDir.resolve("build/createClasspathManifest")
-
-val createClasspathManifest by tasks.registering {
-    dependsOn(plugin.task(":createClasspathManifest"))
-    dependsOn(artifactsTask("jvm"))
-    dependsOn(artifactsTask("jsIr"))
-    dependsOn(artifactsTask("wasm"))
-    dependsOn(artifactsTask("allMetadata"))
-    dependsOn(artifactsTaskNativeKlibs())
-
-    val outputDir = file("$buildDir/$name")
-    outputs.dir(outputDir)
-    doLast {
-        outputDir.apply {
-            mkdirs()
-            resolve("plugin-classpath.txt").writeText(plugin.classpath().resolve("plugin-classpath.txt").readText())
-            resolve("runtime-metadata.txt").writeText(artifactsTask("allMetadata").archiveFilePath)
-            resolve("runtime-jvm.txt").writeText(artifactsTask("jvm").archiveFilePath)
-            resolve("runtime-jsIr.txt").writeText(artifactsTask("jsIr").archiveFilePath)
-            resolve("runtime-wasm.txt").writeText(artifactsTask("wasm").archiveFilePath)
-            resolve("runtime-native.txt").writeText(artifactsTaskNativeKlibs().klibs())
-        }
-    }
-}
-
 dependencies {
-    implementation(files(createClasspathManifest))
     implementation(gradleTestKit())
 
     testImplementation(kotlin("test-junit"))
 }
 
 tasks.test {
+    dependsOn(plugin.task(":publishToBuildLocal"))
+    dependsOn(runtime.tasks.getByName("publishToBuildLocal"))
+
+    systemProperty("plugin_repo_url", plugin.projectDir.resolve("build/maven").absoluteFile.invariantSeparatorsPath)
+    systemProperty("runtime_repo_url", rootProject.buildDir.resolve("maven").absoluteFile.invariantSeparatorsPath)
     systemProperty("kotlin_repo_url", rootProject.properties["kotlin_repo_url"])
+    systemProperty("kotlin_version", rootProject.properties["kotlin_version"]!!)
 }

integration/src/main/kotlin/kotlinx/benchmark/integration/ProjectBuilder.kt

@@ -1,7 +1,5 @@
 package kotlinx.benchmark.integration
 
-import java.io.*
-
 class ProjectBuilder {
     private val configurations = mutableMapOf<String, BenchmarkConfiguration>()
     private val targets = mutableMapOf<String, BenchmarkTarget>()
@@ -31,35 +29,30 @@ benchmark {
     }
 }
 
-private val buildScript = run {
+private val kotlin_repo = System.getProperty("kotlin_repo_url").let {
+    if (it.isNullOrBlank()) "" else "maven { url '$it' }"
+}
+
+private val buildScript =
     """
     buildscript {
+        repositories {
+            $kotlin_repo
+            maven { url '${System.getProperty("plugin_repo_url")}' }
+            mavenCentral()
+        }
         dependencies {
-            classpath files(${readFileList("plugin-classpath.txt")})
+            classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:${System.getProperty("kotlin_version")}'
+            classpath 'org.jetbrains.kotlinx:kotlinx-benchmark-plugin:0.5.0-SNAPSHOT'
         }
     }
     
     apply plugin: 'kotlin-multiplatform'
     apply plugin: 'org.jetbrains.kotlinx.benchmark'
     
     repositories {
+        $kotlin_repo
+        maven { url '${System.getProperty("runtime_repo_url")}' }
         mavenCentral()
-        maven { url 'https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap' }
     }
-    
-    def benchmarkRuntimeMetadata = files(${readFileList("runtime-metadata.txt")})
-    def benchmarkRuntimeJvm = files(${readFileList("runtime-jvm.txt")})
-    def benchmarkRuntimeJsIr = files(${readFileList("runtime-jsIr.txt")})
-    def benchmarkRuntimeWasm = files(${readFileList("runtime-wasm.txt")})
-    def benchmarkRuntimeNative = files(${readFileList("runtime-native.txt")})
     """.trimIndent()
-}
-
-private fun readFileList(fileName: String): String {
-    val resource = ProjectBuilder::class.java.classLoader.getResource(fileName)
-        ?: throw IllegalStateException("Could not find resource '$fileName'")
-    val files = File(resource.toURI())
-        .readLines()
-        .map { File(it).absolutePath.replace("\\", "\\\\") } // escape backslashes in Windows paths
-    return files.joinToString(", ") { "'$it'" }
-}

integration/src/test/kotlin/kotlinx/benchmark/integration/GradleTest.kt

@@ -27,10 +27,6 @@ abstract class GradleTest {
         templates.resolve(name).copyRecursively(rootProjectDir)
         file("build.gradle").modify(builder::build)
         file("settings.gradle").writeText("") // empty settings file
-        val kotlinDevUrl = System.getProperty("kotlin_repo_url")
-        if (!kotlinDevUrl.isNullOrBlank()) {
-            file("gradle.properties").appendText("\nkotlin_repo_url=$kotlinDevUrl")
-        }
         return Runner(rootProjectDir, print, gradleVersion)
     }
 }

integration/src/test/resources/templates/kotlin-multiplatform/build.gradle

@@ -16,46 +16,23 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                implementation(benchmarkRuntimeMetadata)
+                implementation("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.5.0-SNAPSHOT")
             }
         }
         jvmMain {
-            dependencies {
-                implementation(benchmarkRuntimeJvm)
-            }
         }
         jvmBenchmark {
             dependsOn(jvmMain)
-            dependencies {
-                implementation(benchmarkRuntimeJvm)
-            }
         }
         jsIrMain {
-            dependencies {
-                implementation(benchmarkRuntimeJsIr)
-            }
         }
         wasmMain {
-            dependencies {
-                implementation(benchmarkRuntimeWasm)
-            }
         }
         nativeMain {
-            dependsOn(commonMain)
-            dependencies {
-                implementation(benchmarkRuntimeNative)
-            }
         }
     }
 }
 
-repositories {
-    def kotlinDevUrl = rootProject.properties["kotlin_repo_url"]
-    if (kotlinDevUrl != null) {
-        maven { url = kotlinDevUrl }
-    }
-}
-
 benchmark {
     targets {
         register("jvm")