Fix the failing OptionsValidationTest

Abduqodiri Qurbonzoda · Abduqodiri Qurbonzoda · commit 159b5fb0775f · 2023-08-13T14:51:33.000+03:00
The expected message was incorrect, which lead to failed build.
Also rectify the list of valid options.
diff --git a/integration/src/test/kotlin/kotlinx/benchmark/integration/OptionsValidationTest.kt b/integration/src/test/kotlin/kotlinx/benchmark/integration/OptionsValidationTest.kt
@@ -1,6 +1,5 @@
 package kotlinx.benchmark.integration
 
-import java.io.*
 import kotlin.test.*
 
 class OptionsValidationTest : GradleTest() {
@@ -17,7 +16,7 @@ class OptionsValidationTest : GradleTest() {
         }
 
         runner.runAndFail("invalidReportFormatBenchmark") {
-            assertOutputContains("Invalid report format: 'htmll'. Accepted formats: json, csv, scsv, text (e.g., reportFormat = 'json').")
+            assertOutputContains("Invalid report format: 'htmll'. Accepted formats: json, csv, scsv, text (e.g., reportFormat = \"json\").")
         }
     }
 
@@ -67,6 +66,12 @@ class OptionsValidationTest : GradleTest() {
         }
     }
 
+    private val validTimeUnits = "NANOSECONDS, ns, nanos, " +
+            "MICROSECONDS, us, micros, " +
+            "MILLISECONDS, ms, millis, " +
+            "SECONDS, s, sec, " +
+            "MINUTES, m, min"
+
     @Test
     fun testIterationTimeUnitValidation() {
         val runner = project("kotlin-multiplatform") {
@@ -75,13 +80,34 @@ class OptionsValidationTest : GradleTest() {
                 iterationTime = 100
                 iterationTimeUnit = "x"
             }
+            configuration("incorrectCaseIterationTimeUnit") {
+                iterations = 1
+                iterationTime = 1
+                iterationTimeUnit = "seconds"
+            }
         }
 
         runner.runAndFail("invalidIterationTimeUnitBenchmark") {
-            assertOutputContains("Invalid iterationTimeUnit: 'x'. Accepted units: seconds, s, microseconds, us, milliseconds, ms, nanoseconds, ns, minutes, m (e.g., iterationTimeUnit = 'ms').")
+            assertOutputContains("Invalid iterationTimeUnit: 'x'. Accepted units: $validTimeUnits (e.g., iterationTimeUnit = \"ms\").")
+        }
+        runner.runAndFail("incorrectCaseIterationTimeUnitBenchmark") {
+            assertOutputContains("Invalid iterationTimeUnit: 'seconds'. Accepted units: $validTimeUnits (e.g., iterationTimeUnit = \"ms\").")
         }
     }
 
+    @Test
+    fun testValidOptions() {
+        val runner = project("kotlin-multiplatform") {
+            configuration("validOptions") {
+                iterations = 1
+                iterationTime = 1
+                iterationTimeUnit = "SECONDS"
+                mode = "AverageTime"
+            }
+        }
+        runner.run("validOptionsBenchmark") // Successful
+    }
+
     @Test
     fun testModeValidation() {
         val runner = project("kotlin-multiplatform") {
@@ -94,7 +120,7 @@ class OptionsValidationTest : GradleTest() {
         }
 
         runner.runAndFail("invalidModeBenchmark") {
-            assertOutputContains("Invalid benchmark mode: 'x'. Accepted modes: thrpt, avgt (e.g., mode = 'thrpt').")
+            assertOutputContains("Invalid benchmark mode: 'x'. Accepted modes: thrpt, avgt (e.g., mode = \"thrpt\").")
         }
     }
 
@@ -110,7 +136,7 @@ class OptionsValidationTest : GradleTest() {
         }
 
         runner.runAndFail("invalidOutputTimeUnitBenchmark") {
-            assertOutputContains("Invalid outputTimeUnit: 'x'. Accepted units: seconds, s, microseconds, us, milliseconds, ms, nanoseconds, ns, minutes, m (e.g., outputTimeUnit = 'ns').")
+            assertOutputContains("Invalid outputTimeUnit: 'x'. Accepted units: $validTimeUnits (e.g., outputTimeUnit = \"ns\").")
         }
     }
 
@@ -172,6 +198,13 @@ class OptionsValidationTest : GradleTest() {
                 advanced(" ", "value")
             }
 
+            configuration("invalidAdvancedConfigName") {
+                iterations = 1
+                iterationTime = 100
+                iterationTimeUnit = "ms"
+                advanced("jsFork", "value")
+            }
+
             configuration("invalidNativeFork") {
                 iterations = 1
                 iterationTime = 100
@@ -202,19 +235,22 @@ class OptionsValidationTest : GradleTest() {
         }
 
         runner.runAndFail("blankAdvancedConfigNameBenchmark") {
-            assertOutputContains("Invalid advanced config name: ' '. It must not be blank.")
+            assertOutputContains("Invalid advanced option name: ' '. It must not be blank.")
+        }
+        runner.runAndFail("invalidAdvancedConfigNameBenchmark") {
+            assertOutputContains("Invalid advanced option name: 'jsFork'. Accepted options: \"nativeFork\", \"nativeGCAfterIteration\", \"jvmForks\", \"jsUseBridge\".")
         }
         runner.runAndFail("invalidNativeForkBenchmark") {
-            assertOutputContains("Invalid value 'x' for 'nativeFork'. Accepted values: 'perBenchmark', 'perIteration' (e.g., nativeFork = 'perBenchmark').")
+            assertOutputContains("Invalid value for 'nativeFork': 'x'. Accepted values: perBenchmark, perIteration.")
         }
         runner.runAndFail("invalidNativeGCAfterIterationBenchmark") {
-            assertOutputContains("Invalid value 'x' for 'nativeGCAfterIteration'. Expected a boolean value (e.g., nativeGCAfterIteration = true).")
+            assertOutputContains("Invalid value for 'nativeGCAfterIteration': 'x'. Expected a Boolean value.")
         }
         runner.runAndFail("invalidJvmForksBenchmark") {
-            assertOutputContains("Invalid value '-1' for 'jvmForks'. Expected a non-negative integer or 'definedByJmh' (e.g., jvmForks = 2 or jvmForks = 'definedByJmh').")
+            assertOutputContains("Invalid value for 'jvmForks': '-1'. Expected a non-negative integer or \"definedByJmh\".")
         }
         runner.runAndFail("invalidJsUseBridgeBenchmark") {
-            assertOutputContains("Invalid value 'x' for 'jsUseBridge'. Expected a boolean value (e.g., jsUseBridge = true).")
+            assertOutputContains("Invalid value for 'jsUseBridge': 'x'. Expected a Boolean value.")
         }
     }
 }
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/Utils.kt b/plugin/main/src/kotlinx/benchmark/gradle/Utils.kt
@@ -134,9 +134,8 @@ fun writeParameters(
 
 private fun validateConfig(config: BenchmarkConfiguration) {
     config.reportFormat?.let {
-        val validFormats = setOf("json", "csv", "scsv", "text")
-        require(it.toLowerCase() in validFormats) {
-            "Invalid report format: '$it'. Accepted formats: ${validFormats.joinToString(", ")} (e.g., reportFormat = 'json')."
+        require(it.toLowerCase() in ValidOptions.format) {
+            "Invalid report format: '$it'. Accepted formats: ${ValidOptions.format.joinToString(", ")} (e.g., reportFormat = \"json\")."
         }
     }
 
@@ -162,26 +161,23 @@ private fun validateConfig(config: BenchmarkConfiguration) {
     }
 
     config.iterationTimeUnit?.let {
-        val validTimeUnits = setOf("seconds", "s", "microseconds", "us", "milliseconds", "ms", "nanoseconds", "ns", "minutes", "m")
-        require(it.toLowerCase() in validTimeUnits) {
-            "Invalid iterationTimeUnit: '$it'. Accepted units: ${validTimeUnits.joinToString(", ")} (e.g., iterationTimeUnit = 'ms')."
+        require(it in ValidOptions.timeUnits) {
+            "Invalid iterationTimeUnit: '$it'. Accepted units: ${ValidOptions.timeUnits.joinToString(", ")} (e.g., iterationTimeUnit = \"ms\")."
         }
         require(config.iterationTime != null) {
             "Missing iterationTime. Please provide iterationTime when specifying iterationTimeUnit."
         }
     }
 
     config.mode?.let {
-        val validModes = setOf("thrpt", "avgt")
-        require(it.toLowerCase() in validModes) {
-            "Invalid benchmark mode: '$it'. Accepted modes: ${validModes.joinToString(", ")} (e.g., mode = 'thrpt')."
+        require(it in ValidOptions.modes) {
+            "Invalid benchmark mode: '$it'. Accepted modes: ${ValidOptions.modes.joinToString(", ")} (e.g., mode = \"thrpt\")."
         }
     }
     
     config.outputTimeUnit?.let {
-        val validTimeUnits = setOf("seconds", "s", "microseconds", "us", "milliseconds", "ms", "nanoseconds", "ns", "minutes", "m")
-        require(it.toLowerCase() in validTimeUnits) {
-            "Invalid outputTimeUnit: '$it'. Accepted units: ${validTimeUnits.joinToString(", ")} (e.g., outputTimeUnit = 'ns')."
+        require(it in ValidOptions.timeUnits) {
+            "Invalid outputTimeUnit: '$it'. Accepted units: ${ValidOptions.timeUnits.joinToString(", ")} (e.g., outputTimeUnit = \"ns\")."
         }
     }    
 
@@ -207,38 +203,49 @@ private fun validateConfig(config: BenchmarkConfiguration) {
     }
 
     config.advanced.forEach { (param, value) ->
-        println("Validating advanced param: $param with value: $value")
         require(param.isNotBlank()) {
-            "Invalid advanced config param: '$param'. It must not be blank."
+            "Invalid advanced option name: '$param'. It must not be blank."
         }
         require(value.toString().isNotBlank()) {
-            "Invalid value for param '$param': '$value'. Value should not be blank."
+            "Invalid value for advanced option '$param': '$value'. Value should not be blank."
         }
 
         when (param) {
             "nativeFork" -> {
-                val validValues = setOf("perbenchmark", "periteration")
-                require(value.toString().toLowerCase() in validValues) {
-                    "Invalid value for 'nativeFork': '$value'. Accepted values: ${validValues.joinToString(", ")}."
+                require(value.toString() in ValidOptions.nativeForks) {
+                    "Invalid value for 'nativeFork': '$value'. Accepted values: ${ValidOptions.nativeForks.joinToString(", ")}."
                 }
             }
             "nativeGCAfterIteration" -> require(value is Boolean) {
                 "Invalid value for 'nativeGCAfterIteration': '$value'. Expected a Boolean value."
             }
             "jvmForks" -> {
                 val intValue = value.toString().toIntOrNull()
-                require(intValue != null && intValue >= 0 || value.toString().toLowerCase() == "definedbyjmh") {
-                    "Invalid value for 'jvmForks': '$value'. Expected a non-negative integer or 'definedByJmh'."
+                require(intValue != null && intValue >= 0 || value.toString() == "definedByJmh") {
+                    "Invalid value for 'jvmForks': '$value'. Expected a non-negative integer or \"definedByJmh\"."
                 }
             }
             "jsUseBridge" -> require(value is Boolean) {
                 "Invalid value for 'jsUseBridge': '$value'. Expected a Boolean value."
             }
-            else -> throw IllegalArgumentException("Invalid advanced config parameter: '$param'. Accepted parameters: 'nativeFork', 'nativeGCAfterIteration', 'jvmForks', 'jsUseBridge'.")
+            else -> throw IllegalArgumentException("Invalid advanced option name: '$param'. Accepted options: \"nativeFork\", \"nativeGCAfterIteration\", \"jvmForks\", \"jsUseBridge\".")
         }
     }
 }
 
+private object ValidOptions {
+    val format = setOf("json", "csv", "scsv", "text")
+    val timeUnits = setOf(
+        "NANOSECONDS", "ns", "nanos",
+        "MICROSECONDS", "us", "micros",
+        "MILLISECONDS", "ms", "millis",
+        "SECONDS", "s", "sec",
+        "MINUTES", "m", "min"
+    )
+    val modes = setOf("thrpt", "avgt", "Throughput", "AverageTime")
+    val nativeForks = setOf("perBenchmark", "perIteration")
+}
+
 internal val Gradle.isConfigurationCacheAvailable
     get() = try {
         val startParameters = gradle.startParameter

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`package kotlinx.benchmark.integration`
`2`	`2`
`3`		`-import java.io.*`
`4`	`3`	`import kotlin.test.*`
`5`	`4`
`6`	`5`	`class OptionsValidationTest : GradleTest() {`
`@@ -17,7 +16,7 @@ class OptionsValidationTest : GradleTest() {`
`17`	`16`	`}`
`18`	`17`
`19`	`18`	`runner.runAndFail("invalidReportFormatBenchmark") {`
`20`		`- assertOutputContains("Invalid report format: 'htmll'. Accepted formats: json, csv, scsv, text (e.g., reportFormat = 'json').")`
	`19`	`+ assertOutputContains("Invalid report format: 'htmll'. Accepted formats: json, csv, scsv, text (e.g., reportFormat = \"json\").")`
`21`	`20`	`}`
`22`	`21`	`}`
`23`	`22`
`@@ -67,6 +66,12 @@ class OptionsValidationTest : GradleTest() {`
`67`	`66`	`}`
`68`	`67`	`}`
`69`	`68`
	`69`	`+ private val validTimeUnits = "NANOSECONDS, ns, nanos, " +`
	`70`	`+ "MICROSECONDS, us, micros, " +`
	`71`	`+ "MILLISECONDS, ms, millis, " +`
	`72`	`+ "SECONDS, s, sec, " +`
	`73`	`+ "MINUTES, m, min"`
	`74`	`+`
`70`	`75`	`@Test`
`71`	`76`	`fun testIterationTimeUnitValidation() {`
`72`	`77`	`val runner = project("kotlin-multiplatform") {`
`@@ -75,13 +80,34 @@ class OptionsValidationTest : GradleTest() {`
`75`	`80`	`iterationTime = 100`
`76`	`81`	`iterationTimeUnit = "x"`
`77`	`82`	`}`
	`83`	`+ configuration("incorrectCaseIterationTimeUnit") {`
	`84`	`+ iterations = 1`
	`85`	`+ iterationTime = 1`
	`86`	`+ iterationTimeUnit = "seconds"`
	`87`	`+ }`
`78`	`88`	`}`
`79`	`89`
`80`	`90`	`runner.runAndFail("invalidIterationTimeUnitBenchmark") {`
`81`		`- assertOutputContains("Invalid iterationTimeUnit: 'x'. Accepted units: seconds, s, microseconds, us, milliseconds, ms, nanoseconds, ns, minutes, m (e.g., iterationTimeUnit = 'ms').")`
	`91`	`+ assertOutputContains("Invalid iterationTimeUnit: 'x'. Accepted units: $validTimeUnits (e.g., iterationTimeUnit = \"ms\").")`
	`92`	`+ }`
	`93`	`+ runner.runAndFail("incorrectCaseIterationTimeUnitBenchmark") {`
	`94`	`+ assertOutputContains("Invalid iterationTimeUnit: 'seconds'. Accepted units: $validTimeUnits (e.g., iterationTimeUnit = \"ms\").")`
`82`	`95`	`}`
`83`	`96`	`}`
`84`	`97`
	`98`	`+ @Test`
	`99`	`+ fun testValidOptions() {`
	`100`	`+ val runner = project("kotlin-multiplatform") {`
	`101`	`+ configuration("validOptions") {`
	`102`	`+ iterations = 1`
	`103`	`+ iterationTime = 1`
	`104`	`+ iterationTimeUnit = "SECONDS"`
	`105`	`+ mode = "AverageTime"`
	`106`	`+ }`
	`107`	`+ }`
	`108`	`+ runner.run("validOptionsBenchmark") // Successful`
	`109`	`+ }`
	`110`	`+`
`85`	`111`	`@Test`
`86`	`112`	`fun testModeValidation() {`
`87`	`113`	`val runner = project("kotlin-multiplatform") {`
`@@ -94,7 +120,7 @@ class OptionsValidationTest : GradleTest() {`
`94`	`120`	`}`
`95`	`121`
`96`	`122`	`runner.runAndFail("invalidModeBenchmark") {`
`97`		`- assertOutputContains("Invalid benchmark mode: 'x'. Accepted modes: thrpt, avgt (e.g., mode = 'thrpt').")`
	`123`	`+ assertOutputContains("Invalid benchmark mode: 'x'. Accepted modes: thrpt, avgt (e.g., mode = \"thrpt\").")`
`98`	`124`	`}`
`99`	`125`	`}`
`100`	`126`
`@@ -110,7 +136,7 @@ class OptionsValidationTest : GradleTest() {`
`110`	`136`	`}`
`111`	`137`
`112`	`138`	`runner.runAndFail("invalidOutputTimeUnitBenchmark") {`
`113`		`- assertOutputContains("Invalid outputTimeUnit: 'x'. Accepted units: seconds, s, microseconds, us, milliseconds, ms, nanoseconds, ns, minutes, m (e.g., outputTimeUnit = 'ns').")`
	`139`	`+ assertOutputContains("Invalid outputTimeUnit: 'x'. Accepted units: $validTimeUnits (e.g., outputTimeUnit = \"ns\").")`
`114`	`140`	`}`
`115`	`141`	`}`
`116`	`142`
`@@ -172,6 +198,13 @@ class OptionsValidationTest : GradleTest() {`
`172`	`198`	`advanced(" ", "value")`
`173`	`199`	`}`
`174`	`200`
	`201`	`+ configuration("invalidAdvancedConfigName") {`
	`202`	`+ iterations = 1`
	`203`	`+ iterationTime = 100`
	`204`	`+ iterationTimeUnit = "ms"`
	`205`	`+ advanced("jsFork", "value")`
	`206`	`+ }`
	`207`	`+`
`175`	`208`	`configuration("invalidNativeFork") {`
`176`	`209`	`iterations = 1`
`177`	`210`	`iterationTime = 100`
`@@ -202,19 +235,22 @@ class OptionsValidationTest : GradleTest() {`
`202`	`235`	`}`
`203`	`236`
`204`	`237`	`runner.runAndFail("blankAdvancedConfigNameBenchmark") {`
`205`		`- assertOutputContains("Invalid advanced config name: ' '. It must not be blank.")`
	`238`	`+ assertOutputContains("Invalid advanced option name: ' '. It must not be blank.")`
	`239`	`+ }`
	`240`	`+ runner.runAndFail("invalidAdvancedConfigNameBenchmark") {`
	`241`	`+ assertOutputContains("Invalid advanced option name: 'jsFork'. Accepted options: \"nativeFork\", \"nativeGCAfterIteration\", \"jvmForks\", \"jsUseBridge\".")`
`206`	`242`	`}`
`207`	`243`	`runner.runAndFail("invalidNativeForkBenchmark") {`
`208`		`- assertOutputContains("Invalid value 'x' for 'nativeFork'. Accepted values: 'perBenchmark', 'perIteration' (e.g., nativeFork = 'perBenchmark').")`
	`244`	`+ assertOutputContains("Invalid value for 'nativeFork': 'x'. Accepted values: perBenchmark, perIteration.")`
`209`	`245`	`}`
`210`	`246`	`runner.runAndFail("invalidNativeGCAfterIterationBenchmark") {`
`211`		`- assertOutputContains("Invalid value 'x' for 'nativeGCAfterIteration'. Expected a boolean value (e.g., nativeGCAfterIteration = true).")`
	`247`	`+ assertOutputContains("Invalid value for 'nativeGCAfterIteration': 'x'. Expected a Boolean value.")`
`212`	`248`	`}`
`213`	`249`	`runner.runAndFail("invalidJvmForksBenchmark") {`
`214`		`- assertOutputContains("Invalid value '-1' for 'jvmForks'. Expected a non-negative integer or 'definedByJmh' (e.g., jvmForks = 2 or jvmForks = 'definedByJmh').")`
	`250`	`+ assertOutputContains("Invalid value for 'jvmForks': '-1'. Expected a non-negative integer or \"definedByJmh\".")`
`215`	`251`	`}`
`216`	`252`	`runner.runAndFail("invalidJsUseBridgeBenchmark") {`
`217`		`- assertOutputContains("Invalid value 'x' for 'jsUseBridge'. Expected a boolean value (e.g., jsUseBridge = true).")`
	`253`	`+ assertOutputContains("Invalid value for 'jsUseBridge': 'x'. Expected a Boolean value.")`
`218`	`254`	`}`
`219`	`255`	`}`
`220`	`256`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,9 +134,8 @@ fun writeParameters(`
`134`	`134`
`135`	`135`	`private fun validateConfig(config: BenchmarkConfiguration) {`
`136`	`136`	`config.reportFormat?.let {`
`137`		`- val validFormats = setOf("json", "csv", "scsv", "text")`
`138`		`- require(it.toLowerCase() in validFormats) {`
`139`		`- "Invalid report format: '$it'. Accepted formats: ${validFormats.joinToString(", ")} (e.g., reportFormat = 'json')."`
	`137`	`+ require(it.toLowerCase() in ValidOptions.format) {`
	`138`	`+ "Invalid report format: '$it'. Accepted formats: ${ValidOptions.format.joinToString(", ")} (e.g., reportFormat = \"json\")."`
`140`	`139`	`}`
`141`	`140`	`}`
`142`	`141`
`@@ -162,26 +161,23 @@ private fun validateConfig(config: BenchmarkConfiguration) {`
`162`	`161`	`}`
`163`	`162`
`164`	`163`	`config.iterationTimeUnit?.let {`
`165`		`- val validTimeUnits = setOf("seconds", "s", "microseconds", "us", "milliseconds", "ms", "nanoseconds", "ns", "minutes", "m")`
`166`		`- require(it.toLowerCase() in validTimeUnits) {`
`167`		`- "Invalid iterationTimeUnit: '$it'. Accepted units: ${validTimeUnits.joinToString(", ")} (e.g., iterationTimeUnit = 'ms')."`
	`164`	`+ require(it in ValidOptions.timeUnits) {`
	`165`	`+ "Invalid iterationTimeUnit: '$it'. Accepted units: ${ValidOptions.timeUnits.joinToString(", ")} (e.g., iterationTimeUnit = \"ms\")."`
`168`	`166`	`}`
`169`	`167`	`require(config.iterationTime != null) {`
`170`	`168`	`"Missing iterationTime. Please provide iterationTime when specifying iterationTimeUnit."`
`171`	`169`	`}`
`172`	`170`	`}`
`173`	`171`
`174`	`172`	`config.mode?.let {`
`175`		`- val validModes = setOf("thrpt", "avgt")`
`176`		`- require(it.toLowerCase() in validModes) {`
`177`		`- "Invalid benchmark mode: '$it'. Accepted modes: ${validModes.joinToString(", ")} (e.g., mode = 'thrpt')."`
	`173`	`+ require(it in ValidOptions.modes) {`
	`174`	`+ "Invalid benchmark mode: '$it'. Accepted modes: ${ValidOptions.modes.joinToString(", ")} (e.g., mode = \"thrpt\")."`
`178`	`175`	`}`
`179`	`176`	`}`
`180`	`177`
`181`	`178`	`config.outputTimeUnit?.let {`
`182`		`- val validTimeUnits = setOf("seconds", "s", "microseconds", "us", "milliseconds", "ms", "nanoseconds", "ns", "minutes", "m")`
`183`		`- require(it.toLowerCase() in validTimeUnits) {`
`184`		`- "Invalid outputTimeUnit: '$it'. Accepted units: ${validTimeUnits.joinToString(", ")} (e.g., outputTimeUnit = 'ns')."`
	`179`	`+ require(it in ValidOptions.timeUnits) {`
	`180`	`+ "Invalid outputTimeUnit: '$it'. Accepted units: ${ValidOptions.timeUnits.joinToString(", ")} (e.g., outputTimeUnit = \"ns\")."`
`185`	`181`	`}`
`186`	`182`	`}`
`187`	`183`
`@@ -207,38 +203,49 @@ private fun validateConfig(config: BenchmarkConfiguration) {`
`207`	`203`	`}`
`208`	`204`
`209`	`205`	`config.advanced.forEach { (param, value) ->`
`210`		`- println("Validating advanced param: $param with value: $value")`
`211`	`206`	`require(param.isNotBlank()) {`
`212`		`- "Invalid advanced config param: '$param'. It must not be blank."`
	`207`	`+ "Invalid advanced option name: '$param'. It must not be blank."`
`213`	`208`	`}`
`214`	`209`	`require(value.toString().isNotBlank()) {`
`215`		`- "Invalid value for param '$param': '$value'. Value should not be blank."`
	`210`	`+ "Invalid value for advanced option '$param': '$value'. Value should not be blank."`
`216`	`211`	`}`
`217`	`212`
`218`	`213`	`when (param) {`
`219`	`214`	`"nativeFork" -> {`
`220`		`- val validValues = setOf("perbenchmark", "periteration")`
`221`		`- require(value.toString().toLowerCase() in validValues) {`
`222`		`- "Invalid value for 'nativeFork': '$value'. Accepted values: ${validValues.joinToString(", ")}."`
	`215`	`+ require(value.toString() in ValidOptions.nativeForks) {`
	`216`	`+ "Invalid value for 'nativeFork': '$value'. Accepted values: ${ValidOptions.nativeForks.joinToString(", ")}."`
`223`	`217`	`}`
`224`	`218`	`}`
`225`	`219`	`"nativeGCAfterIteration" -> require(value is Boolean) {`
`226`	`220`	`"Invalid value for 'nativeGCAfterIteration': '$value'. Expected a Boolean value."`
`227`	`221`	`}`
`228`	`222`	`"jvmForks" -> {`
`229`	`223`	`val intValue = value.toString().toIntOrNull()`
`230`		`- require(intValue != null && intValue >= 0 \|\| value.toString().toLowerCase() == "definedbyjmh") {`
`231`		`- "Invalid value for 'jvmForks': '$value'. Expected a non-negative integer or 'definedByJmh'."`
	`224`	`+ require(intValue != null && intValue >= 0 \|\| value.toString() == "definedByJmh") {`
	`225`	`+ "Invalid value for 'jvmForks': '$value'. Expected a non-negative integer or \"definedByJmh\"."`
`232`	`226`	`}`
`233`	`227`	`}`
`234`	`228`	`"jsUseBridge" -> require(value is Boolean) {`
`235`	`229`	`"Invalid value for 'jsUseBridge': '$value'. Expected a Boolean value."`
`236`	`230`	`}`
`237`		`- else -> throw IllegalArgumentException("Invalid advanced config parameter: '$param'. Accepted parameters: 'nativeFork', 'nativeGCAfterIteration', 'jvmForks', 'jsUseBridge'.")`
	`231`	`+ else -> throw IllegalArgumentException("Invalid advanced option name: '$param'. Accepted options: \"nativeFork\", \"nativeGCAfterIteration\", \"jvmForks\", \"jsUseBridge\".")`
`238`	`232`	`}`
`239`	`233`	`}`
`240`	`234`	`}`
`241`	`235`
	`236`	`+private object ValidOptions {`
	`237`	`+ val format = setOf("json", "csv", "scsv", "text")`
	`238`	`+ val timeUnits = setOf(`
	`239`	`+ "NANOSECONDS", "ns", "nanos",`
	`240`	`+ "MICROSECONDS", "us", "micros",`
	`241`	`+ "MILLISECONDS", "ms", "millis",`
	`242`	`+ "SECONDS", "s", "sec",`
	`243`	`+ "MINUTES", "m", "min"`
	`244`	`+ )`
	`245`	`+ val modes = setOf("thrpt", "avgt", "Throughput", "AverageTime")`
	`246`	`+ val nativeForks = setOf("perBenchmark", "perIteration")`
	`247`	`+}`
	`248`	`+`
`242`	`249`	`internal val Gradle.isConfigurationCacheAvailable`
`243`	`250`	`get() = try {`
`244`	`251`	`val startParameters = gradle.startParameter`