From 21cbaaec374635b17690a54a14545c51bb93415d Mon Sep 17 00:00:00 2001 From: hg42 Date: Mon, 16 Sep 2024 17:46:49 +0200 Subject: [PATCH] fix generator scripts (exclude from module, invoke only manual) --- build.gradle.kts | 45 +- gradle/libs.versions.toml | 1 + ...UI_derivedStateVsRememberKey.generator.kts | 139 ++ .../Try_UI_derivedStateVsRememberKey.main.kts | 110 -- ..._UI_derivedStateVsRememberKey_generator.rb | 101 -- .../Try_UI_derviedStateVsRememberKey.kt | 1248 +++++++++-------- ...Try_UI_derviedStateVsRememberKey.kt.backup | 893 ------------ .../Try_UI_derviedStateVsRememberKey.kt.keep | 822 ----------- 8 files changed, 818 insertions(+), 2541 deletions(-) create mode 100644 src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey.generator.kts delete mode 100644 src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey.main.kts delete mode 100644 src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey_generator.rb delete mode 100644 src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt.backup delete mode 100644 src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt.keep diff --git a/build.gradle.kts b/build.gradle.kts index 32437c6441..98da0073d0 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -23,8 +23,11 @@ plugins { alias(libs.plugins.kotlin.compose) alias(libs.plugins.kotlin.serialization) alias(libs.plugins.ksp) + //alias(libs.plugins.kotlin.scripting) } +val jvmVersion = JavaVersion.VERSION_17 + android { namespace = "com.machiav3lli.backup" compileSdk = 34 @@ -86,13 +89,28 @@ android { compose = true } compileOptions { - sourceCompatibility = JavaVersion.VERSION_17 - targetCompatibility = JavaVersion.VERSION_17 + sourceCompatibility = jvmVersion + targetCompatibility = jvmVersion } - tasks.withType { - kotlinOptions { - jvmTarget = compileOptions.sourceCompatibility.toString() - freeCompilerArgs = listOf("-Xjvm-default=all") + kotlin { + jvmToolchain(jvmVersion.toString().toInt()) + compilerOptions { + freeCompilerArgs.addAll( + "-Xjvm-default=all", + //"-Xuse-fir-lt=false", // Scripts are not yet supported with K2 in LightTree mode + //"-Xallow-any-scripts-in-source-roots", + ) + if (project.findProperty("enableComposeCompilerReports") == "true") { + val metricsDir = + "${project.layout.buildDirectory.asFile.get().absolutePath}/compose_metrics" + println("--- enableComposeCompilerReports -> $metricsDir") + freeCompilerArgs.addAll( + "-P", + "plugin:androidx.compose.compiler.plugins.kotlin:reportsDestination=$metricsDir", + "-P", + "plugin:androidx.compose.compiler.plugins.kotlin:metricsDestination=$metricsDir", + ) + } } } lint { @@ -121,7 +139,7 @@ android { dependencies { implementation(libs.kotlin.stdlib) implementation(libs.ksp) - implementation(libs.kotlin.reflect) + // not yet necessary: implementation(libs.kotlin.reflect) // Koin implementation(libs.koin.android) @@ -180,9 +198,9 @@ dependencies { debugImplementation(libs.compose.ui.test.manifest) //---------------------------------------- hg42 // can only be enabled on demand, otherwise it conflicts with compilation - // TODO hg42 without thew library the .main.kts script still works, but syntax checking is not working - // TODO hg42 and ide complains about script at wrong place + // TODO hg42 without the library the .main.kts script still works, but syntax checking is not working //implementation(libs.kotlin.main.kts) + implementation(kotlin("script-runtime")) // for intellisense in kts scripts } // using a task as a preBuild dependency instead of a function that takes some time insures that it runs @@ -213,3 +231,12 @@ tasks.withType { // useTestNG() // useJUnitPlatform() } + + +// Exclude (non-gradle) kts scripts from compilation +tasks.withType().configureEach { + setSource(sources.filterNot { + //it.name.endsWith(".generator.kts") + it.extension == "kts" + }) +} diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 29598e84e9..9e78b8b1d6 100755 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -108,5 +108,6 @@ kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" } kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" } +kotlin-scripting = { id = "org.jetbrains.kotlin.plugin.scripting", version.ref = "kotlin" } ######################################## hg42 diff --git a/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey.generator.kts b/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey.generator.kts new file mode 100644 index 0000000000..3b86dabcec --- /dev/null +++ b/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey.generator.kts @@ -0,0 +1,139 @@ +import java.io.File +import java.time.LocalDateTime +import java.time.format.DateTimeFormatter + +println() +println("-------------------------------------------------------------------------------------------") +println() + +val class_name = "Try_UI_derviedStateVsRememberKey" +val file = class_name + ".kt" +val file_template = class_name + ".kt" +val file_backup = class_name + ".kt.backup" +val time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss")) + +val composables = listOf( + + "DerivedState_from_Value: val value by remember { derivedStateOf { externalValue } }", + "DerivedState_from_Param: val value by remember { derivedStateOf { param } }", + "RememberKey_Value_stateofValue: val value by remember(externalValue ) { mutableStateOf ( externalValue ) }", + "RememberKey_Value_stateofValue10: val value by remember(externalValue ) { mutableStateOf ( externalValue / 10 ) }", + "RememberKey_Value10_stateofValue10: val value by remember(externalValue / 10) { mutableStateOf ( externalValue / 10 ) }", + "RememberKey_Value_Value: val value = remember(externalValue ) { externalValue }", + "RememberKey_Value_Value10: val value = remember(externalValue ) { externalValue / 10 }", + "RememberKey_Value10_Value10: val value = remember(externalValue / 10) { externalValue / 10 }", + "Remember__stateofParam: val value by remember { mutableStateOf ( param ) }", + "Remember__stateofParam10: val value by remember { mutableStateOf ( param / 10 ) }", + "Remember__Param: val value = remember { param }", + "Remember__Param10: val value = remember { param / 10 }", + "DerivedState_State: val value by remember { derivedStateOf { externalState.value } }", + "DerivedState_State10: val value by remember { derivedStateOf { externalState.value / 10 } }", + "DerivedState_StateValue: val value by remember { derivedStateOf { externalStateValue } }", + "DerivedState_StateValue10: val value by remember { derivedStateOf { externalStateValue / 10 } }", + "DerivedState_byState: val value by remember { derivedStateOf { externalByState } }", + "DerivedState_byState10: val value by remember { derivedStateOf { externalByState / 10 } }", + "DerivedState_byStateValue: val value by remember { derivedStateOf { externalByStateValue } }", + "DerivedState_byStateValue10: val value by remember { derivedStateOf { externalByStateValue / 10 } }", + "RememberKey_State_stateofState: val value by remember(externalState.value ) { mutableStateOf ( externalState.value ) }", + "RememberKey_State_stateofState10: val value by remember(externalState.value ) { mutableStateOf ( externalState.value / 10 ) }", + "RememberKey_State10_stateofState10: val value by remember(externalState.value / 10) { mutableStateOf ( externalState.value / 10 ) }", + "RememberKey_State_State: val value = remember(externalState.value ) { externalState.value }", + "RememberKey_State_State10: val value = remember(externalState.value ) { externalState.value / 10 }", + "RememberKey_State10_State10: val value = remember(externalState.value / 10) { externalState.value / 10 }", + "RememberKey_byState_byState: val value = remember(externalByState ) { externalByState }", + "RememberKey_byState_byState10: val value = remember(externalByState ) { externalByState / 10 }", + "RememberKey_byState10_byState10: val value = remember(externalByState / 10) { externalByState / 10 }", + "RememberKey_byStateValue_byStateValue: val value = remember(externalByStateValue ) { externalByStateValue }", + "RememberKey_byStateValue_byStateValue10: val value = remember(externalByStateValue ) { externalByStateValue / 10 }", + "RememberKey_byStateValue10_byStateValue10: val value = remember(externalByStateValue / 10) { externalByStateValue / 10 }", + "RememberKey_Param_stateofParam: val value by remember(param ) { mutableStateOf ( param ) }", + "RememberKey_Param_stateofParam10: val value by remember(param ) { mutableStateOf ( param / 10 ) }", + "RememberKey_Param10_stateofParam10: val value by remember(param / 10) { mutableStateOf ( param / 10 ) }", + "RememberKey_Param_Param: val value = remember(param ) { param }", + "RememberKey_Param_Param10: val value = remember(param ) { param / 10 }", + "RememberKey_Param10_Param10: val value = remember(param / 10) { param / 10 }", + "Param: val value = param ", + "Param10: val value = param / 10 ", + + ) + .map { + val (name, prepare) = it.split(Regex(": *"), limit = 2) + Pair(name, prepare) + } + .toMap() + +val functions = composables.map { (name, prepare) -> + + val args = if (prepare.contains("param")) "(param: Int)" else "()" + + val prepare = prepare.replace(Regex(""" +"""), " ") + + """ + @Composable + fun ${name}${args} { + ${prepare} + Row { + Text( + text = " ${'$'}value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" ${name}") + Spacer(modifier = Modifier.weight(1f)) + } + } + """ +}.joinToString("\n") + +val indent = " " + +val invocations = composables.map { (name, prepare) -> + + val args = if (prepare.contains("param")) "(externalValue)" else "()" + + indent + "${name}${args}" + +}.joinToString("\n") + +var text = File(file_template).readText() + +//File(file_backup).writeText(text) + +var changes = 0 + +// use matchEntire instead of replace because replacement can contain '$' + +run { + val match = Regex( + """(.*^ *//functions-begin *$).*(^ *//functions-end *$.*)""", + options = setOf(RegexOption.DOT_MATCHES_ALL, RegexOption.MULTILINE) + ).matchEntire(text) + if (match != null) { + text = match.groups[1]!!.value + functions + match.groups[2]!!.value + changes++ + } else + println("no change in functions") +} + +run { + val match = Regex( + """(.*^ *//invocations-begin *$).*(^ *//invocations-end *$.*)""", + options = setOf(RegexOption.DOT_MATCHES_ALL, RegexOption.MULTILINE) + ).matchEntire(text) + if (match != null) { + text = + match.groups[1]!!.value + + "\n Text(\"\")\n\n$invocations\n\n Text(\"\")\n Text(\"generated: ${time}\")\n" + + match.groups[2]!!.value + changes++ + } else + println("no change in invocations") +} + +if (changes > 0) { + File(file).writeText(text) + println(text) +} else + println("no changes!") diff --git a/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey.main.kts b/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey.main.kts deleted file mode 100644 index 87469c2b6c..0000000000 --- a/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey.main.kts +++ /dev/null @@ -1,110 +0,0 @@ - -import java.time.LocalDateTime -import java.time.format.DateTimeFormatter -import java.io.File - -println() -println("-------------------------------------------------------------------------------------------") -println() - -val class_name = "Try_UI_derviedStateVsRememberKey" -val file = class_name + ".kt" -val file_template = class_name + ".kt" -val file_backup = class_name + ".kt.backup" -val time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss")) - -val composables = mapOf( - "DerivedState_from_Value" to "val value by remember { derivedStateOf { externalValue } }", - "DerivedState_from_Param" to "val value by remember { derivedStateOf { param } }", - "RememberKey_Value_stateofValue" to "val value by remember(externalValue ) { mutableStateOf ( externalValue ) }", - "RememberKey_Value_stateofValue10" to "val value by remember(externalValue ) { mutableStateOf ( externalValue / 10 ) }", - "RememberKey_Value10_stateofValue10" to "val value by remember(externalValue / 10) { mutableStateOf ( externalValue / 10 ) }", - "RememberKey_Value_Value" to "val value = remember(externalValue ) { externalValue }", - "RememberKey_Value_Value10" to "val value = remember(externalValue ) { externalValue / 10 }", - "RememberKey_Value10_Value10" to "val value = remember(externalValue / 10) { externalValue / 10 }", - "Remember__stateofParam" to "val value by remember { mutableStateOf ( param ) }", - "Remember__stateofParam10" to "val value by remember { mutableStateOf ( param / 10 ) }", - "Remember__Param" to "val value = remember { param }", - "Remember__Param10" to "val value = remember { param / 10 }", - "DerivedState_State" to "val value by remember { derivedStateOf { externalState.value } }", - "DerivedState_State10" to "val value by remember { derivedStateOf { externalState.value / 10 } }", - "DerivedState_StateValue" to "val value by remember { derivedStateOf { externalStateValue } }", - "DerivedState_StateValue10" to "val value by remember { derivedStateOf { externalStateValue / 10 } }", - "DerivedState_byState" to "val value by remember { derivedStateOf { externalByState } }", - "DerivedState_byState10" to "val value by remember { derivedStateOf { externalByState / 10 } }", - "DerivedState_byStateValue" to "val value by remember { derivedStateOf { externalByStateValue } }", - "DerivedState_byStateValue10" to "val value by remember { derivedStateOf { externalByStateValue / 10 } }", - "RememberKey_State_stateofState" to "val value by remember(externalState.value ) { mutableStateOf ( externalState.value ) }", - "RememberKey_State_stateofState10" to "val value by remember(externalState.value ) { mutableStateOf ( externalState.value / 10 ) }", - "RememberKey_State10_stateofState10" to "val value by remember(externalState.value / 10) { mutableStateOf ( externalState.value / 10 ) }", - "RememberKey_State_State" to "val value = remember(externalState.value ) { externalState.value }", - "RememberKey_State_State10" to "val value = remember(externalState.value ) { externalState.value / 10 }", - "RememberKey_State10_State10" to "val value = remember(externalState.value / 10) { externalState.value / 10 }", - "RememberKey_byState_byState" to "val value = remember(externalByState ) { externalByState }", - "RememberKey_byState_byState10" to "val value = remember(externalByState ) { externalByState / 10 }", - "RememberKey_byState10_byState10" to "val value = remember(externalByState / 10) { externalByState / 10 }", - "RememberKey_byStateValue_byStateValue" to "val value = remember(externalByStateValue ) { externalByStateValue }", - "RememberKey_byStateValue_byStateValue10" to "val value = remember(externalByStateValue ) { externalByStateValue / 10 }", - "RememberKey_byStateValue10_byStateValue10" to "val value = remember(externalByStateValue / 10) { externalByStateValue / 10 }", - "RememberKey_Param_stateofParam" to "val value by remember(param ) { mutableStateOf ( param ) }", - "RememberKey_Param_stateofParam10" to "val value by remember(param ) { mutableStateOf ( param / 10 ) }", - "RememberKey_Param10_stateofParam10" to "val value by remember(param / 10) { mutableStateOf ( param / 10 ) }", - "RememberKey_Param_Param" to "val value = remember(param ) { param }", - "RememberKey_Param_Param10" to "val value = remember(param ) { param / 10 }", - "RememberKey_Param10_Param10" to "val value = remember(param / 10) { param / 10 }", - "Param" to "val value = param ", - "Param10" to "val value = param / 10 ", -) - -val functions = composables.map { (name, prepare) -> - - val args = if (prepare.matches(Regex("""param"""))) "(param: Int)" else "()" - - val prepare = prepare.replace(Regex(""" +"""), " ") - - """ - @Composable - fun ${name}${args} { - ${prepare} - Row { - Text( - text = " ${'$'}value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" ${name}", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } - } - """ -}.joinToString("\n") - -val indent = " " - -val invocations = composables.map { (name, prepare) -> - - val args = if (prepare.matches(Regex("""param"""))) "(externalValue)" else "()" - - indent + "#{name}#{args}" - -}.joinToString("\n") - -var text = File(file_template).readText() - -File(file_backup).writeText(text) - -text = text.replace( - Regex("""(\n *//functions-begin *\n).*(\n *//functions-end *\n)""", option = RegexOption.MULTILINE), - """\1""" + """\n""" + functions + """\2""" - ) - -text = text.replace( - Regex("""(\n *//invocations-begin *\n).*(\n *//invocations-end *\n)""", option = RegexOption.MULTILINE), - """\1""" + """\n Text("")\n\n""" + invocations + """\n\n Text("")\n Text("generated: ${time}")\n""" + """\2""" - ) - -println(text) - -File(file).writeText(text) diff --git a/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey_generator.rb b/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey_generator.rb deleted file mode 100644 index f9d2323d43..0000000000 --- a/src/androidTest/kotlin/research/Try_UI_derivedStateVsRememberKey_generator.rb +++ /dev/null @@ -1,101 +0,0 @@ -#!/usr/bin/ruby - -class_name = "Try_UI_derviedStateVsRememberKey" -file = class_name + ".kt" -file_template = class_name + ".kt" -file_backup = class_name + ".kt.backup" -time = Time.now - -composables = { -"DerivedState_from_Value" => "val value by remember { derivedStateOf { externalValue } }", -"DerivedState_from_Param" => "val value by remember { derivedStateOf { param } }", -"RememberKey_Value_stateofValue" => "val value by remember(externalValue ) { mutableStateOf ( externalValue ) }", -"RememberKey_Value_stateofValue10" => "val value by remember(externalValue ) { mutableStateOf ( externalValue / 10 ) }", -"RememberKey_Value10_stateofValue10" => "val value by remember(externalValue / 10) { mutableStateOf ( externalValue / 10 ) }", -"RememberKey_Value_Value" => "val value = remember(externalValue ) { externalValue }", -"RememberKey_Value_Value10" => "val value = remember(externalValue ) { externalValue / 10 }", -"RememberKey_Value10_Value10" => "val value = remember(externalValue / 10) { externalValue / 10 }", -"Remember__stateofParam" => "val value by remember { mutableStateOf ( param ) }", -"Remember__stateofParam10" => "val value by remember { mutableStateOf ( param / 10 ) }", -"Remember__Param" => "val value = remember { param }", -"Remember__Param10" => "val value = remember { param / 10 }", -"DerivedState_State" => "val value by remember { derivedStateOf { externalState.value } }", -"DerivedState_State10" => "val value by remember { derivedStateOf { externalState.value / 10 } }", -"DerivedState_StateValue" => "val value by remember { derivedStateOf { externalStateValue } }", -"DerivedState_StateValue10" => "val value by remember { derivedStateOf { externalStateValue / 10 } }", -"DerivedState_byState" => "val value by remember { derivedStateOf { externalByState } }", -"DerivedState_byState10" => "val value by remember { derivedStateOf { externalByState / 10 } }", -"DerivedState_byStateValue" => "val value by remember { derivedStateOf { externalByStateValue } }", -"DerivedState_byStateValue10" => "val value by remember { derivedStateOf { externalByStateValue / 10 } }", -"RememberKey_State_stateofState" => "val value by remember(externalState.value ) { mutableStateOf ( externalState.value ) }", -"RememberKey_State_stateofState10" => "val value by remember(externalState.value ) { mutableStateOf ( externalState.value / 10 ) }", -"RememberKey_State10_stateofState10" => "val value by remember(externalState.value / 10) { mutableStateOf ( externalState.value / 10 ) }", -"RememberKey_State_State" => "val value = remember(externalState.value ) { externalState.value }", -"RememberKey_State_State10" => "val value = remember(externalState.value ) { externalState.value / 10 }", -"RememberKey_State10_State10" => "val value = remember(externalState.value / 10) { externalState.value / 10 }", -"RememberKey_byState_byState" => "val value = remember(externalByState ) { externalByState }", -"RememberKey_byState_byState10" => "val value = remember(externalByState ) { externalByState / 10 }", -"RememberKey_byState10_byState10" => "val value = remember(externalByState / 10) { externalByState / 10 }", -"RememberKey_byStateValue_byStateValue" => "val value = remember(externalByStateValue ) { externalByStateValue }", -"RememberKey_byStateValue_byStateValue10" => "val value = remember(externalByStateValue ) { externalByStateValue / 10 }", -"RememberKey_byStateValue10_byStateValue10" => "val value = remember(externalByStateValue / 10) { externalByStateValue / 10 }", -"RememberKey_Param_stateofParam" => "val value by remember(param ) { mutableStateOf ( param ) }", -"RememberKey_Param_stateofParam10" => "val value by remember(param ) { mutableStateOf ( param / 10 ) }", -"RememberKey_Param10_stateofParam10" => "val value by remember(param / 10) { mutableStateOf ( param / 10 ) }", -"RememberKey_Param_Param" => "val value = remember(param ) { param }", -"RememberKey_Param_Param10" => "val value = remember(param ) { param / 10 }", -"RememberKey_Param10_Param10" => "val value = remember(param / 10) { param / 10 }", -"Param" => "val value = param ", -"Param10" => "val value = param / 10 ", -} - -functions = composables.map {|e| - (name, prepare) = e - - args = if prepare =~ %r(param) then "(param: Int)" else "()" end - prepare.gsub!(%r( +), " ") - - <<"---" -@Composable -fun #{name}#{args} { - #{prepare} - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" #{name}", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} ---- -}.join("\n") - -indent = " " - -invocations = composables.map {|e| - (name, prepare) = e - args = if prepare =~ %r(param) then "(externalValue)" else "()" end - indent + "#{name}#{args}" -}.join("\n") - -text = File.open(file_template).read() - -File.open(file_backup, "w").write(text) - -text.sub!( - %r{(\n *//functions-begin *\n).*(\n *//functions-end *\n)}m, - '\1' + "\n" + functions + '\2' -) - -text.sub!( - %r{(\n *//invocations-begin *\n).*(\n *//invocations-end *\n)}m, - '\1' + "\n Text(\"\")\n\n" + invocations + "\n\n Text(\"\")\n Text(\"generated: #{time}\")\n" + '\2' -) - -puts text - -File.open(file, "w").write(text) diff --git a/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt b/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt index 42ecd884f8..970a67d875 100644 --- a/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt +++ b/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt @@ -131,648 +131,685 @@ private val recomposeModifier = } //functions-begin - -@Composable -fun DerivedState_from_Value() { - val value by remember { derivedStateOf { externalValue } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_Value", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + @Composable + fun DerivedState_from_Value() { + val value by remember { derivedStateOf { externalValue } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_from_Value") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_from_Param(param: Int) { - val value by remember { derivedStateOf { param } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_from_Param(param: Int) { + val value by remember { derivedStateOf { param } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_from_Param") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Value_stateofValue() { - val value by remember(externalValue ) { mutableStateOf ( externalValue ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_stateofValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Value_stateofValue() { + val value by remember(externalValue ) { mutableStateOf ( externalValue ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Value_stateofValue") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Value_stateofValue10() { - val value by remember(externalValue ) { mutableStateOf ( externalValue / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_stateofValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Value_stateofValue10() { + val value by remember(externalValue ) { mutableStateOf ( externalValue / 10 ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Value_stateofValue10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Value10_stateofValue10() { - val value by remember(externalValue / 10) { mutableStateOf ( externalValue / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value10_stateofValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Value10_stateofValue10() { + val value by remember(externalValue / 10) { mutableStateOf ( externalValue / 10 ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Value10_stateofValue10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Value_Value() { - val value = remember(externalValue ) { externalValue } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_Value", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Value_Value() { + val value = remember(externalValue ) { externalValue } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Value_Value") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Value_Value10() { - val value = remember(externalValue ) { externalValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_Value10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Value_Value10() { + val value = remember(externalValue ) { externalValue / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Value_Value10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Value10_Value10() { - val value = remember(externalValue / 10) { externalValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value10_Value10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Value10_Value10() { + val value = remember(externalValue / 10) { externalValue / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Value10_Value10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun Remember__stateofParam(param: Int) { - val value by remember { mutableStateOf ( param ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__stateofParam", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun Remember__stateofParam(param: Int) { + val value by remember { mutableStateOf ( param ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" Remember__stateofParam") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun Remember__stateofParam10(param: Int) { - val value by remember { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun Remember__stateofParam10(param: Int) { + val value by remember { mutableStateOf ( param / 10 ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" Remember__stateofParam10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun Remember__Param(param: Int) { - val value = remember { param } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun Remember__Param(param: Int) { + val value = remember { param } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" Remember__Param") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun Remember__Param10(param: Int) { - val value = remember { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun Remember__Param10(param: Int) { + val value = remember { param / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" Remember__Param10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_State() { - val value by remember { derivedStateOf { externalState.value } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_State", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_State() { + val value by remember { derivedStateOf { externalState.value } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_State") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_State10() { - val value by remember { derivedStateOf { externalState.value / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_State10() { + val value by remember { derivedStateOf { externalState.value / 10 } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_State10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_StateValue() { - val value by remember { derivedStateOf { externalStateValue } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_StateValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_StateValue() { + val value by remember { derivedStateOf { externalStateValue } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_StateValue") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_StateValue10() { - val value by remember { derivedStateOf { externalStateValue / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_StateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_StateValue10() { + val value by remember { derivedStateOf { externalStateValue / 10 } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_StateValue10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_byState() { - val value by remember { derivedStateOf { externalByState } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_byState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_byState() { + val value by remember { derivedStateOf { externalByState } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_byState") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_byState10() { - val value by remember { derivedStateOf { externalByState / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_byState10() { + val value by remember { derivedStateOf { externalByState / 10 } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_byState10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_byStateValue() { - val value by remember { derivedStateOf { externalByStateValue } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_byStateValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_byStateValue() { + val value by remember { derivedStateOf { externalByStateValue } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_byStateValue") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun DerivedState_byStateValue10() { - val value by remember { derivedStateOf { externalByStateValue / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_byStateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun DerivedState_byStateValue10() { + val value by remember { derivedStateOf { externalByStateValue / 10 } } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" DerivedState_byStateValue10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_State_stateofState() { - val value by remember(externalState.value ) { mutableStateOf ( externalState.value ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_stateofState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_State_stateofState() { + val value by remember(externalState.value ) { mutableStateOf ( externalState.value ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_State_stateofState") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_State_stateofState10() { - val value by remember(externalState.value ) { mutableStateOf ( externalState.value / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_stateofState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_State_stateofState10() { + val value by remember(externalState.value ) { mutableStateOf ( externalState.value / 10 ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_State_stateofState10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_State10_stateofState10() { - val value by remember(externalState.value / 10) { mutableStateOf ( externalState.value / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State10_stateofState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_State10_stateofState10() { + val value by remember(externalState.value / 10) { mutableStateOf ( externalState.value / 10 ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_State10_stateofState10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_State_State() { - val value = remember(externalState.value ) { externalState.value } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_State", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_State_State() { + val value = remember(externalState.value ) { externalState.value } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_State_State") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_State_State10() { - val value = remember(externalState.value ) { externalState.value / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_State_State10() { + val value = remember(externalState.value ) { externalState.value / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_State_State10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_State10_State10() { - val value = remember(externalState.value / 10) { externalState.value / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State10_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_State10_State10() { + val value = remember(externalState.value / 10) { externalState.value / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_State10_State10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_byState_byState() { - val value = remember(externalByState ) { externalByState } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState_byState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_byState_byState() { + val value = remember(externalByState ) { externalByState } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_byState_byState") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_byState_byState10() { - val value = remember(externalByState ) { externalByState / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_byState_byState10() { + val value = remember(externalByState ) { externalByState / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_byState_byState10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_byState10_byState10() { - val value = remember(externalByState / 10) { externalByState / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState10_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_byState10_byState10() { + val value = remember(externalByState / 10) { externalByState / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_byState10_byState10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_byStateValue_byStateValue() { - val value = remember(externalByStateValue ) { externalByStateValue } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue_byStateValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_byStateValue_byStateValue() { + val value = remember(externalByStateValue ) { externalByStateValue } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_byStateValue_byStateValue") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_byStateValue_byStateValue10() { - val value = remember(externalByStateValue ) { externalByStateValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue_byStateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_byStateValue_byStateValue10() { + val value = remember(externalByStateValue ) { externalByStateValue / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_byStateValue_byStateValue10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_byStateValue10_byStateValue10() { - val value = remember(externalByStateValue / 10) { externalByStateValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue10_byStateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_byStateValue10_byStateValue10() { + val value = remember(externalByStateValue / 10) { externalByStateValue / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_byStateValue10_byStateValue10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Param_stateofParam(param: Int) { - val value by remember(param ) { mutableStateOf ( param ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_stateofParam", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Param_stateofParam(param: Int) { + val value by remember(param ) { mutableStateOf ( param ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Param_stateofParam") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Param_stateofParam10(param: Int) { - val value by remember(param ) { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Param_stateofParam10(param: Int) { + val value by remember(param ) { mutableStateOf ( param / 10 ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Param_stateofParam10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Param10_stateofParam10(param: Int) { - val value by remember(param / 10) { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param10_stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Param10_stateofParam10(param: Int) { + val value by remember(param / 10) { mutableStateOf ( param / 10 ) } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Param10_stateofParam10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Param_Param(param: Int) { - val value = remember(param ) { param } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Param_Param(param: Int) { + val value = remember(param ) { param } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Param_Param") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Param_Param10(param: Int) { - val value = remember(param ) { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Param_Param10(param: Int) { + val value = remember(param ) { param / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Param_Param10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun RememberKey_Param10_Param10(param: Int) { - val value = remember(param / 10) { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param10_Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun RememberKey_Param10_Param10(param: Int) { + val value = remember(param / 10) { param / 10 } + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" RememberKey_Param10_Param10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun Param(param: Int) { - val value = param - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun Param(param: Int) { + val value = param + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" Param") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -@Composable -fun Param10(param: Int) { - val value = param / 10 - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) + + + @Composable + fun Param10(param: Int) { + val value = param / 10 + Row { + Text( + text = " $value ", + textAlign = TextAlign.End, + modifier = Modifier + .width(70.dp) + .recomposeHighlighter() + ) + Text(" Param10") + Spacer(modifier = Modifier.weight(1f)) + } } -} - -//functions-end + //functions-end @Composable fun TheComposable() { @@ -791,7 +828,6 @@ fun TheComposable() { Text("externalByStateValue: ${externalByStateValue}") //invocations-begin - Text("") DerivedState_from_Value() @@ -836,8 +872,7 @@ fun TheComposable() { Param10(externalValue) Text("") - Text("generated: 2024-08-05 10:54:40 +0200") - + Text("generated: 2024-09-16_17-22-08") //invocations-end } } @@ -876,7 +911,8 @@ class Try_UI_derivedStateVsRememberKey { startCounter() test.waitUntil(60000) { - externalValue >= 50000/countTime + //externalValue >= 50000/countTime + externalValue >= 200 } } } diff --git a/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt.backup b/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt.backup deleted file mode 100644 index 42ecd884f8..0000000000 --- a/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt.backup +++ /dev/null @@ -1,893 +0,0 @@ -package tests.research.Try_UI_derivedStateVsRememberKey - -import androidx.compose.foundation.background -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.width -import androidx.compose.material3.ElevatedButton -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.Stable -import androidx.compose.runtime.derivedStateOf -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Modifier -import androidx.compose.ui.composed -import androidx.compose.ui.draw.drawWithCache -import androidx.compose.ui.geometry.Offset -import androidx.compose.ui.geometry.Size -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.SolidColor -import androidx.compose.ui.graphics.drawscope.Fill -import androidx.compose.ui.graphics.drawscope.Stroke -import androidx.compose.ui.graphics.lerp -import androidx.compose.ui.platform.debugInspectorInfo -import androidx.compose.ui.test.junit4.createComposeRule -import androidx.compose.ui.test.onRoot -import androidx.compose.ui.test.printToLog -import androidx.compose.ui.text.style.TextAlign -import androidx.compose.ui.tooling.preview.Preview -import androidx.compose.ui.unit.dp -import androidx.test.ext.junit.runners.AndroidJUnit4 -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.delay -import kotlinx.coroutines.launch -import org.junit.Before -import org.junit.Rule -import org.junit.Test -import org.junit.runner.RunWith -import kotlin.math.min - -val countTime = 100 -val resetTime = 200 - -var externalState = mutableStateOf(0) -var externalByState by mutableStateOf(0) -val externalStateValue get() = externalState.value -val externalByStateValue get() = externalByState -var externalValue = 0 - -@Composable -fun ActionButton(name: String, onClick: () -> Unit) { - ElevatedButton(onClick = onClick) { - Text(name, style = MaterialTheme.typography.bodyLarge) - } -} - -@Stable -fun Modifier.recomposeHighlighter(): Modifier = this.then(recomposeModifier) - -// Use a single instance + @Stable to ensure that recompositions can enable skipping optimizations -// Modifier.composed will still remember unique data per call site. -private val recomposeModifier = - Modifier.composed(inspectorInfo = debugInspectorInfo { - name = "recomposeHighlighter" - }) { - // The total number of compositions that have occurred. We're not using a State<> here be - // able to read/write the value without invalidating (which would cause infinite - // recomposition). - val totalCompositions = remember { arrayOf(0L) } - totalCompositions[0]++ - // The value of totalCompositions at the last timeout. - val totalCompositionsAtLastTimeout = remember { mutableStateOf(0L) } - // Start the timeout, and reset everytime there's a recomposition. (Using totalCompositions - // as the key is really just to cause the timer to restart every composition). - LaunchedEffect(totalCompositions[0]) { - delay(resetTime.toLong()) - totalCompositionsAtLastTimeout.value = totalCompositions[0] - } - Modifier.drawWithCache { - onDrawWithContent { - // Draw actual content. - drawContent() - // Below is to draw the highlight, if necessary. A lot of the logic is copied from - // Modifier.border - val numCompositionsSinceTimeout = - totalCompositions[0] - totalCompositionsAtLastTimeout.value - val hasValidBorderParams = size.minDimension > 0f - if (!hasValidBorderParams || numCompositionsSinceTimeout <= 0) { - return@onDrawWithContent - } - val (color, strokeWidthPx) = - when (numCompositionsSinceTimeout) { - // We need at least one composition to draw, so draw the smallest border - // color in blue. - 1L -> Color.Cyan.copy(alpha = 0.5f) to 1.dp.toPx() - // 2 compositions is _probably_ okay. - 2L -> Color.Blue.copy(alpha = 0.5f) to 1.dp.toPx() - // 3 or more compositions before timeout may indicate an issue. lerp the - // color from yellow to red, and continually increase the border size. - else -> { - lerp( - Color.Green.copy(alpha = 0.3f), - Color.Red.copy(alpha = 0.5f), - min(1f, (numCompositionsSinceTimeout - 1).toFloat() / 100f) - ) to 2.dp.toPx() //numCompositionsSinceTimeout.toInt().dp.toPx() - } - } - val halfStroke = strokeWidthPx / 2 - val topLeft = Offset(halfStroke, halfStroke) - val borderSize = - Size(size.width - strokeWidthPx, size.height - strokeWidthPx) - val fillArea = (strokeWidthPx * 2) > size.minDimension - val rectTopLeft = if (fillArea) Offset.Zero else topLeft - val size = if (fillArea) size else borderSize - val style = if (fillArea) Fill else Stroke(strokeWidthPx) - drawRect( - brush = SolidColor(color), - topLeft = rectTopLeft, - size = size, - style = style - ) - } - } - } - -//functions-begin - -@Composable -fun DerivedState_from_Value() { - val value by remember { derivedStateOf { externalValue } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_Value", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_from_Param(param: Int) { - val value by remember { derivedStateOf { param } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value_stateofValue() { - val value by remember(externalValue ) { mutableStateOf ( externalValue ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_stateofValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value_stateofValue10() { - val value by remember(externalValue ) { mutableStateOf ( externalValue / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_stateofValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value10_stateofValue10() { - val value by remember(externalValue / 10) { mutableStateOf ( externalValue / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value10_stateofValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value_Value() { - val value = remember(externalValue ) { externalValue } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_Value", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value_Value10() { - val value = remember(externalValue ) { externalValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_Value10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value10_Value10() { - val value = remember(externalValue / 10) { externalValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value10_Value10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Remember__stateofParam(param: Int) { - val value by remember { mutableStateOf ( param ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__stateofParam", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Remember__stateofParam10(param: Int) { - val value by remember { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Remember__Param(param: Int) { - val value = remember { param } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Remember__Param10(param: Int) { - val value = remember { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_State() { - val value by remember { derivedStateOf { externalState.value } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_State", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_State10() { - val value by remember { derivedStateOf { externalState.value / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_StateValue() { - val value by remember { derivedStateOf { externalStateValue } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_StateValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_StateValue10() { - val value by remember { derivedStateOf { externalStateValue / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_StateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_byState() { - val value by remember { derivedStateOf { externalByState } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_byState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_byState10() { - val value by remember { derivedStateOf { externalByState / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_byStateValue() { - val value by remember { derivedStateOf { externalByStateValue } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_byStateValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_byStateValue10() { - val value by remember { derivedStateOf { externalByStateValue / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_byStateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State_stateofState() { - val value by remember(externalState.value ) { mutableStateOf ( externalState.value ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_stateofState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State_stateofState10() { - val value by remember(externalState.value ) { mutableStateOf ( externalState.value / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_stateofState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State10_stateofState10() { - val value by remember(externalState.value / 10) { mutableStateOf ( externalState.value / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State10_stateofState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State_State() { - val value = remember(externalState.value ) { externalState.value } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_State", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State_State10() { - val value = remember(externalState.value ) { externalState.value / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State10_State10() { - val value = remember(externalState.value / 10) { externalState.value / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State10_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byState_byState() { - val value = remember(externalByState ) { externalByState } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState_byState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byState_byState10() { - val value = remember(externalByState ) { externalByState / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byState10_byState10() { - val value = remember(externalByState / 10) { externalByState / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState10_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byStateValue_byStateValue() { - val value = remember(externalByStateValue ) { externalByStateValue } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue_byStateValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byStateValue_byStateValue10() { - val value = remember(externalByStateValue ) { externalByStateValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue_byStateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byStateValue10_byStateValue10() { - val value = remember(externalByStateValue / 10) { externalByStateValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue10_byStateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param_stateofParam(param: Int) { - val value by remember(param ) { mutableStateOf ( param ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_stateofParam", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param_stateofParam10(param: Int) { - val value by remember(param ) { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param10_stateofParam10(param: Int) { - val value by remember(param / 10) { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param10_stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param_Param(param: Int) { - val value = remember(param ) { param } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param_Param10(param: Int) { - val value = remember(param ) { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param10_Param10(param: Int) { - val value = remember(param / 10) { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param10_Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Param(param: Int) { - val value = param - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Param10(param: Int) { - val value = param / 10 - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -//functions-end - -@Composable -fun TheComposable() { - - Column( - modifier = Modifier - .recomposeHighlighter() - .background(MaterialTheme.colorScheme.surfaceContainer) - .padding(8.dp) - ) { - - Text("externalValue: ${externalValue}") - Text("externalState: ${externalState.value}") - Text("externalByState: ${externalByState}") - Text("externalStateValue: ${externalStateValue}") - Text("externalByStateValue: ${externalByStateValue}") - - //invocations-begin - - Text("") - - DerivedState_from_Value() - DerivedState_from_Param(externalValue) - RememberKey_Value_stateofValue() - RememberKey_Value_stateofValue10() - RememberKey_Value10_stateofValue10() - RememberKey_Value_Value() - RememberKey_Value_Value10() - RememberKey_Value10_Value10() - Remember__stateofParam(externalValue) - Remember__stateofParam10(externalValue) - Remember__Param(externalValue) - Remember__Param10(externalValue) - DerivedState_State() - DerivedState_State10() - DerivedState_StateValue() - DerivedState_StateValue10() - DerivedState_byState() - DerivedState_byState10() - DerivedState_byStateValue() - DerivedState_byStateValue10() - RememberKey_State_stateofState() - RememberKey_State_stateofState10() - RememberKey_State10_stateofState10() - RememberKey_State_State() - RememberKey_State_State10() - RememberKey_State10_State10() - RememberKey_byState_byState() - RememberKey_byState_byState10() - RememberKey_byState10_byState10() - RememberKey_byStateValue_byStateValue() - RememberKey_byStateValue_byStateValue10() - RememberKey_byStateValue10_byStateValue10() - RememberKey_Param_stateofParam(externalValue) - RememberKey_Param_stateofParam10(externalValue) - RememberKey_Param10_stateofParam10(externalValue) - RememberKey_Param_Param(externalValue) - RememberKey_Param_Param10(externalValue) - RememberKey_Param10_Param10(externalValue) - Param(externalValue) - Param10(externalValue) - - Text("") - Text("generated: 2024-08-05 10:54:40 +0200") - - //invocations-end - } -} - -fun startCounter() { - externalState.value = 0 - externalByState = 0 - externalValue = 0 - CoroutineScope(Dispatchers.IO).launch { - while (true) { - externalValue++ - externalState.value = externalValue - externalByState = externalValue - delay(countTime.toLong()) - } - } -} - -@RunWith(AndroidJUnit4::class) -class Try_UI_derivedStateVsRememberKey { - - @get:Rule - val test = createComposeRule() - - @Before - fun setUp() { - test.setContent { - TheComposable() - } - test.onRoot().printToLog("root") - } - - @Test - fun test_composables() { - - startCounter() - - test.waitUntil(60000) { - externalValue >= 50000/countTime - } - } -} - -@Preview(showBackground = true) -@Composable -fun Try_UI_derivedStateVsRememberKey_Preview() { - - LaunchedEffect(true) { - startCounter() - } - - TheComposable() -} diff --git a/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt.keep b/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt.keep deleted file mode 100644 index 868a4f85b1..0000000000 --- a/src/androidTest/kotlin/research/Try_UI_derviedStateVsRememberKey.kt.keep +++ /dev/null @@ -1,822 +0,0 @@ -package tests.research.Try_UI_derivedStateVsRememberKey - -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.width -import androidx.compose.material3.ElevatedButton -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.Stable -import androidx.compose.runtime.derivedStateOf -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Modifier -import androidx.compose.ui.composed -import androidx.compose.ui.draw.drawWithCache -import androidx.compose.ui.geometry.Offset -import androidx.compose.ui.geometry.Size -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.SolidColor -import androidx.compose.ui.graphics.drawscope.Fill -import androidx.compose.ui.graphics.drawscope.Stroke -import androidx.compose.ui.graphics.lerp -import androidx.compose.ui.platform.debugInspectorInfo -import androidx.compose.ui.test.junit4.createComposeRule -import androidx.compose.ui.test.onRoot -import androidx.compose.ui.test.printToLog -import androidx.compose.ui.text.style.TextAlign -import androidx.compose.ui.tooling.preview.Preview -import androidx.compose.ui.unit.dp -import androidx.test.ext.junit.runners.AndroidJUnit4 -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.delay -import kotlinx.coroutines.launch -import org.junit.Before -import org.junit.Rule -import org.junit.Test -import org.junit.runner.RunWith -import kotlin.math.min - -val countTime = 100 -val resetTime = 200 - -var externalState = mutableStateOf(0) -var externalByState by mutableStateOf(0) -val externalStateValue get() = externalState.value -val externalByStateValue get() = externalByState -var externalValue = 0 - -@Composable -fun ActionButton(name: String, onClick: () -> Unit) { - ElevatedButton(onClick = onClick) { - Text(name, style = MaterialTheme.typography.bodyLarge) - } -} - -@Stable -fun Modifier.recomposeHighlighter(): Modifier = this.then(recomposeModifier) - -// Use a single instance + @Stable to ensure that recompositions can enable skipping optimizations -// Modifier.composed will still remember unique data per call site. -private val recomposeModifier = - Modifier.composed(inspectorInfo = debugInspectorInfo { - name = "recomposeHighlighter" - }) { - // The total number of compositions that have occurred. We're not using a State<> here be - // able to read/write the value without invalidating (which would cause infinite - // recomposition). - val totalCompositions = remember { arrayOf(0L) } - totalCompositions[0]++ - // The value of totalCompositions at the last timeout. - val totalCompositionsAtLastTimeout = remember { mutableStateOf(0L) } - // Start the timeout, and reset everytime there's a recomposition. (Using totalCompositions - // as the key is really just to cause the timer to restart every composition). - LaunchedEffect(totalCompositions[0]) { - delay(resetTime.toLong()) - totalCompositionsAtLastTimeout.value = totalCompositions[0] - } - Modifier.drawWithCache { - onDrawWithContent { - // Draw actual content. - drawContent() - // Below is to draw the highlight, if necessary. A lot of the logic is copied from - // Modifier.border - val numCompositionsSinceTimeout = - totalCompositions[0] - totalCompositionsAtLastTimeout.value - val hasValidBorderParams = size.minDimension > 0f - if (!hasValidBorderParams || numCompositionsSinceTimeout <= 0) { - return@onDrawWithContent - } - val (color, strokeWidthPx) = - when (numCompositionsSinceTimeout) { - // We need at least one composition to draw, so draw the smallest border - // color in blue. - 1L -> Color.Cyan.copy(alpha = 0.5f) to 1.dp.toPx() - // 2 compositions is _probably_ okay. - 2L -> Color.Blue.copy(alpha = 0.5f) to 1.dp.toPx() - // 3 or more compositions before timeout may indicate an issue. lerp the - // color from yellow to red, and continually increase the border size. - else -> { - lerp( - Color.Green.copy(alpha = 0.3f), - Color.Red.copy(alpha = 0.5f), - min(1f, (numCompositionsSinceTimeout - 1).toFloat() / 100f) - ) to 2.dp.toPx() //numCompositionsSinceTimeout.toInt().dp.toPx() - } - } - val halfStroke = strokeWidthPx / 2 - val topLeft = Offset(halfStroke, halfStroke) - val borderSize = - Size(size.width - strokeWidthPx, size.height - strokeWidthPx) - val fillArea = (strokeWidthPx * 2) > size.minDimension - val rectTopLeft = if (fillArea) Offset.Zero else topLeft - val size = if (fillArea) size else borderSize - val style = if (fillArea) Fill else Stroke(strokeWidthPx) - drawRect( - brush = SolidColor(color), - topLeft = rectTopLeft, - size = size, - style = style - ) - } - } - } - -//functions-begin - -@Composable -fun DerivedState_from_Value() { - val value by remember { derivedStateOf { externalValue } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_Value", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_from_Param(param: Int) { - val value by remember { derivedStateOf { param } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value_stateofValue() { - val value by remember(externalValue ) { mutableStateOf ( externalValue ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_stateofValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value_stateofValue10() { - val value by remember(externalValue ) { mutableStateOf ( externalValue / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_stateofValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value10_stateofValue10() { - val value by remember(externalValue / 10) { mutableStateOf ( externalValue / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value10_stateofValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value_Value() { - val value = remember(externalValue ) { externalValue } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_Value", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value_Value10() { - val value = remember(externalValue ) { externalValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value_Value10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Value10_Value10() { - val value = remember(externalValue / 10) { externalValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Value10_Value10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Remember__stateofParam(param: Int) { - val value by remember { mutableStateOf ( param ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__stateofParam", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Remember__stateofParam10(param: Int) { - val value by remember { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Remember__Param(param: Int) { - val value = remember { param } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Remember__Param10(param: Int) { - val value = remember { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Remember__Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_from_State() { - val value by remember { derivedStateOf { externalState.value } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_State", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_from_State10() { - val value by remember { derivedStateOf { externalState.value / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_from_byState() { - val value by remember { derivedStateOf { externalByState } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_byState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun DerivedState_from_byState10() { - val value by remember { derivedStateOf { externalByState / 10 } } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" DerivedState_from_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State_stateofState() { - val value by remember(externalState.value ) { mutableStateOf ( externalState.value ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_stateofState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State_stateofState10() { - val value by remember(externalState.value ) { mutableStateOf ( externalState.value / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_stateofState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State10_stateofState10() { - val value by remember(externalState.value / 10) { mutableStateOf ( externalState.value / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State10_stateofState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State_State() { - val value = remember(externalState.value ) { externalState.value } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_State", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State_State10() { - val value = remember(externalState.value ) { externalState.value / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_State10_State10() { - val value = remember(externalState.value / 10) { externalState.value / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_State10_State10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byState_byState() { - val value = remember(externalByState ) { externalByState } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState_byState", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byState_byState10() { - val value = remember(externalByState ) { externalByState / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byState10_byState10() { - val value = remember(externalByState / 10) { externalByState / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byState10_byState10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byStateValue_byStateValue() { - val value = remember(externalByStateValue ) { externalByStateValue } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue_byStateValue", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byStateValue_byStateValue10() { - val value = remember(externalByStateValue ) { externalByStateValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue_byStateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_byStateValue10_byStateValue10() { - val value = remember(externalByStateValue / 10) { externalByStateValue / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_byStateValue10_byStateValue10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param_stateofParam(param: Int) { - val value by remember(param ) { mutableStateOf ( param ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_stateofParam", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param_stateofParam10(param: Int) { - val value by remember(param ) { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param10_stateofParam10(param: Int) { - val value by remember(param / 10) { mutableStateOf ( param / 10 ) } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param10_stateofParam10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param_Param(param: Int) { - val value = remember(param ) { param } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param_Param10(param: Int) { - val value = remember(param ) { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param_Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun RememberKey_Param10_Param10(param: Int) { - val value = remember(param / 10) { param / 10 } - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" RememberKey_Param10_Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Param(param: Int) { - val value = param - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Param", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -@Composable -fun Param10(param: Int) { - val value = param / 10 - Row { - Text( - text = " $value ", - textAlign = TextAlign.End, - modifier = Modifier - .width(70.dp) - .recomposeHighlighter() - ) - Text(" Param10", modifier = Modifier.recomposeHighlighter()) - Spacer(modifier = Modifier.weight(1f)) - } -} - -//functions-end - -@Composable -fun TheComposable() { - - Column(modifier = Modifier.recomposeHighlighter().padding(8.dp)) { - - Text("externalValue: ${externalValue}") - Text("externalState: ${externalState.value}") - Text("externalByState: ${externalByState}") - Text("externalStateValue: ${externalStateValue}") - Text("externalByStateValue: ${externalByStateValue}") - - //invocations-begin - - Text("") - - DerivedState_from_Value() - DerivedState_from_Param(externalValue) - RememberKey_Value_stateofValue() - RememberKey_Value_stateofValue10() - RememberKey_Value10_stateofValue10() - RememberKey_Value_Value() - RememberKey_Value_Value10() - RememberKey_Value10_Value10() - Remember__stateofParam(externalValue) - Remember__stateofParam10(externalValue) - Remember__Param(externalValue) - Remember__Param10(externalValue) - DerivedState_from_State() - DerivedState_from_State10() - DerivedState_from_byState() - DerivedState_from_byState10() - RememberKey_State_stateofState() - RememberKey_State_stateofState10() - RememberKey_State10_stateofState10() - RememberKey_State_State() - RememberKey_State_State10() - RememberKey_State10_State10() - RememberKey_byState_byState() - RememberKey_byState_byState10() - RememberKey_byState10_byState10() - RememberKey_byStateValue_byStateValue() - RememberKey_byStateValue_byStateValue10() - RememberKey_byStateValue10_byStateValue10() - RememberKey_Param_stateofParam(externalValue) - RememberKey_Param_stateofParam10(externalValue) - RememberKey_Param10_stateofParam10(externalValue) - RememberKey_Param_Param(externalValue) - RememberKey_Param_Param10(externalValue) - RememberKey_Param10_Param10(externalValue) - Param(externalValue) - Param10(externalValue) - - Text("") - Text("generated: 2024-08-05 10:49:28 +0200") - - //invocations-end - } -} - -fun startCounter() { - externalState.value = 0 - externalByState = 0 - externalValue = 0 - CoroutineScope(Dispatchers.IO).launch { - while (true) { - externalValue++ - externalState.value = externalValue - externalByState = externalValue - delay(countTime.toLong()) - } - } -} - -@RunWith(AndroidJUnit4::class) -class Try_UI_derivedStateVsRememberKey { - - - @get:Rule - val test = createComposeRule() - - @Before - fun setUp() { - //test.setContent { } - } - - @Test - fun test_composables() { - - test.onRoot().printToLog("root") - - startCounter() - - test.runOnUiThread { - test.setContent { - TheComposable() - } - } - } -} - - -@Preview(showBackground = true, backgroundColor = 0xFFFEFEFE) -@Composable -fun Try_UI_derivedStateVsRememberKey_Preview() { - - LaunchedEffect(true) { - startCounter() - } - - TheComposable() -}