Replace deprecated functions

Author: Abduqodiri Qurbonzoda

plugin/main/src/kotlinx/benchmark/gradle/BenchmarksPlugin.kt

@@ -38,8 +38,8 @@ class BenchmarksPlugin : Plugin<Project> {
         val kotlinClass = tryGetClass<KotlinBasePluginWrapper>("org.jetbrains.kotlin.gradle.plugin.KotlinBasePluginWrapper")
         if (kotlinClass != null) {
             plugins.findPlugin(kotlinClass)?.run {
-                logger.info("Detected Kotlin plugin version '$kotlinPluginVersion'")
-                if (VersionNumber.parse(kotlinPluginVersion) < VersionNumber(1, 5, 30, null))
+                logger.info("Detected Kotlin plugin version '${project.getKotlinPluginVersion()}'")
+                if (VersionNumber.parse(project.getKotlinPluginVersion()) < VersionNumber(1, 5, 30, null))
                     logger.error("JetBrains Gradle Benchmarks plugin requires Kotlin version 1.5.30 or higher")
             }
         }

plugin/main/src/kotlinx/benchmark/gradle/Utils.kt

@@ -105,28 +105,28 @@ fun writeParameters(
     validateConfig(config)
     val file = createTempFile("benchmarks")
     file.writeText(buildString {
-        appendln("name:$name")
-        appendln("reportFile:$reportFile")
-        appendln("traceFormat:$format")
-        config.reportFormat?.let { appendln("reportFormat:$it") }
-        config.iterations?.let { appendln("iterations:$it") }
-        config.warmups?.let { appendln("warmups:$it") }
-        config.iterationTime?.let { appendln("iterationTime:$it") }
-        config.iterationTimeUnit?.let { appendln("iterationTimeUnit:$it") }
-        config.outputTimeUnit?.let { appendln("outputTimeUnit:$it") }
-        config.mode?.let { appendln("mode:$it") }
+        appendLine("name:$name")
+        appendLine("reportFile:$reportFile")
+        appendLine("traceFormat:$format")
+        config.reportFormat?.let { appendLine("reportFormat:$it") }
+        config.iterations?.let { appendLine("iterations:$it") }
+        config.warmups?.let { appendLine("warmups:$it") }
+        config.iterationTime?.let { appendLine("iterationTime:$it") }
+        config.iterationTimeUnit?.let { appendLine("iterationTimeUnit:$it") }
+        config.outputTimeUnit?.let { appendLine("outputTimeUnit:$it") }
+        config.mode?.let { appendLine("mode:$it") }
 
         config.includes.forEach {
-            appendln("include:$it")
+            appendLine("include:$it")
         }
         config.excludes.forEach {
-            appendln("exclude:$it")
+            appendLine("exclude:$it")
         }
         config.params.forEach { (param, values) ->
-            values.forEach { value -> appendln("param:$param=$value") }
+            values.forEach { value -> appendLine("param:$param=$value") }
         }
         config.advanced.forEach { (param, value) ->
-            appendln("$param:$value")
+            appendLine("$param:$value")
         }
     })
     return file

runtime/commonMain/src/kotlinx/benchmark/BenchmarkReportFormatter.kt

@@ -6,7 +6,7 @@ sealed class BenchmarkReportFormatter {
     abstract fun format(results: Collection<ReportBenchmarkResult>): String
 
     companion object {
-        fun create(format: String): BenchmarkReportFormatter = when (format.toLowerCase()) {
+        fun create(format: String): BenchmarkReportFormatter = when (format.lowercase()) {
             "json" -> JsonBenchmarkReportFormatter
             "csv" -> CsvBenchmarkReportFormatter(",")
             "scsv" -> CsvBenchmarkReportFormatter(";")
@@ -96,9 +96,9 @@ internal object TextBenchmarkReportFormatter : BenchmarkReportFormatter() {
             val names = s.split(".")
             if (first) {
                 first = false
-                names.takeWhile { it.toLowerCase() == it }
+                names.takeWhile { it.lowercase() == it }
             } else {
-                val common = prefix.zip(names).takeWhile { (p, n) -> p == n && n.toLowerCase() == n }
+                val common = prefix.zip(names).takeWhile { (p, n) -> p == n && n.lowercase() == n }
                 if (prefix.size != common.size) prefixCut = true
                 prefix.take(common.size)
             }

runtime/commonMain/src/kotlinx/benchmark/ExecutorConfiguration.kt

@@ -41,8 +41,8 @@ class BenchmarkConfiguration private constructor(
                 parseTimeUnit(getParameterValue("iterationTimeUnit")),
                 parseTimeUnit(getParameterValue("outputTimeUnit")),
                 getParameterValue("mode").toMode(),
-                NativeIterationMode.valueOf(getParameterValue("nativeIterationMode").capitalize()),
-                NativeGCCollectMode.valueOf(getParameterValue("nativeGCCollectMode").capitalize())
+                NativeIterationMode.valueOf(getParameterValue("nativeIterationMode").replaceFirstChar { it.uppercaseChar() }),
+                NativeGCCollectMode.valueOf(getParameterValue("nativeGCCollectMode").replaceFirstChar { it.uppercaseChar() })
             )
         }
     }

runtime/commonMain/src/kotlinx/benchmark/IntelliJLog.kt

@@ -17,7 +17,7 @@ internal fun ijSuiteFinish(
     append("<ijLog>")
     append("<event type='afterSuite'>")
     append("<test id='$id' parentId='$parent'>")
-    append("<result resultType='${status.toString().toUpperCase()}' startTime='$startTime' endTime='$endTime'/>")
+    append("<result resultType='${status.toString().uppercase()}' startTime='$startTime' endTime='$endTime'/>")
     append("</test>")
     append("</event>")
     append("</ijLog>")
@@ -40,7 +40,7 @@ internal fun ijBenchmarkFinish(
     append("<ijLog>")
     append("<event type='afterTest'>")
     append("<test id='$id' parentId='$parent'>")
-    append("<result resultType='${status.toString().toUpperCase()}' startTime='$startTime' endTime='$endTime'/>")
+    append("<result resultType='${status.toString().uppercase()}' startTime='$startTime' endTime='$endTime'/>")
     append("</test>")
     append("</event>")
     append("</ijLog>")

runtime/commonMain/src/kotlinx/benchmark/ReportBenchmarksStatistics.kt

@@ -37,15 +37,15 @@ class ReportBenchmarksStatistics(values: DoubleArray) {
         else -> values[values.lastIndex]
     }
 
-    fun mean(): Double = values.sumByDouble { it } / size
+    fun mean(): Double = values.sumOf { it } / size
 
     fun standardDeviation(): Double {
         // two-pass algorithm for variance, avoids numeric overflow
         if (size <= 1)
             return 0.0
 
         val mean = mean()
-        val sum = values.sumByDouble { (it - mean).let { it * it } }
+        val sum = values.sumOf { (it - mean).let { it * it } }
         val variance = sum / values.lastIndex
         return sqrt(variance)
     }

runtime/commonMain/src/kotlinx/benchmark/RunnerConfiguration.kt

@@ -70,11 +70,11 @@ class RunnerConfiguration(config: String) {
 
     val nativeIterationMode = singleValueOrNull(
         "nativeIterationMode"
-    ) { NativeIterationMode.valueOf(it.capitalize()) }
+    ) { NativeIterationMode.valueOf(it.replaceFirstChar { firstChar -> firstChar.uppercaseChar() }) }
 
     val nativeGCCollectMode = singleValueOrNull(
         "nativeGCCollectMode"
-    ) { NativeGCCollectMode.valueOf(it.capitalize()) }
+    ) { NativeGCCollectMode.valueOf(it.replaceFirstChar { firstChar -> firstChar.uppercaseChar() }) }
 
     override fun toString(): String {
         return """$name -> $reportFile ($traceFormat, $reportFormat)

runtime/jvmMain/src/kotlinx/benchmark/jvm/JvmBenchmarkRunner.kt

@@ -49,7 +49,7 @@ fun main(args: Array<String>) {
         config.forks > 0 -> jmhOptions.forks(config.forks)
     }
 
-    val reportFormat = ResultFormatType.valueOf(config.reportFormat.toUpperCase())
+    val reportFormat = ResultFormatType.valueOf(config.reportFormat.uppercase())
     val reporter = BenchmarkProgress.create(config.traceFormat)
     val output = JmhOutputFormat(reporter, config.name)
     try {