From d29324bcfb3ce1ebacbb2257e3af249f08e67944 Mon Sep 17 00:00:00 2001 From: Oleksandr Karpovich Date: Mon, 6 Mar 2023 18:30:36 +0100 Subject: [PATCH 1/3] add cases for expect/actual + Compose --- .../src/main/kotlin/TargetsConfiguration.kt | 28 +++- .../src/commonMain/kotlin/CurrentPlatform.kt | 21 +++ .../src/desktopMain/kotlin/Actuals.desktop.kt | 2 + .../common/src/jsMain/kotlin/Actuals.js.kt | 2 + .../src/nativeMain/kotlin/Actuals.native.kt | 2 + .../composable-test-cases/settings.gradle.kts | 3 + .../expectActualFun/lib/build.gradle.kts | 20 +++ .../lib/src/commonMain/kotlin/Dependencies.kt | 66 ++++++++ .../src/desktopMain/kotlin/Actuals.desktop.kt | 82 ++++++++++ .../lib/src/jsMain/kotlin/Actuals.js.kt | 83 ++++++++++ .../src/nativeMain/kotlin/Actuals.native.kt | 82 ++++++++++ .../expectActualFun/main/build.gradle.kts | 21 +++ .../commonTest/kotlin/TestExpectActuals.kt | 142 ++++++++++++++++++ 13 files changed, 553 insertions(+), 1 deletion(-) create mode 100644 compose/integrations/composable-test-cases/common/src/commonMain/kotlin/CurrentPlatform.kt create mode 100644 compose/integrations/composable-test-cases/common/src/desktopMain/kotlin/Actuals.desktop.kt create mode 100644 compose/integrations/composable-test-cases/common/src/jsMain/kotlin/Actuals.js.kt create mode 100644 compose/integrations/composable-test-cases/common/src/nativeMain/kotlin/Actuals.native.kt create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/lib/build.gradle.kts create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/Dependencies.kt create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/Actuals.desktop.kt create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/Actuals.js.kt create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/Actuals.native.kt create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/main/build.gradle.kts create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt diff --git a/compose/integrations/composable-test-cases/buildSrc/src/main/kotlin/TargetsConfiguration.kt b/compose/integrations/composable-test-cases/buildSrc/src/main/kotlin/TargetsConfiguration.kt index 8c9aad69f08..4741e2160b4 100644 --- a/compose/integrations/composable-test-cases/buildSrc/src/main/kotlin/TargetsConfiguration.kt +++ b/compose/integrations/composable-test-cases/buildSrc/src/main/kotlin/TargetsConfiguration.kt @@ -18,6 +18,8 @@ val Project.isFailingJsCase: Boolean @OptIn(ExternalVariantApi::class) fun KotlinMultiplatformExtension.configureTargets() { + val addMinGw = project.isInIdea + jvm("desktop") configureJsTargets() ios() @@ -27,8 +29,32 @@ fun KotlinMultiplatformExtension.configureTargets() { macosX64() macosArm64() // We use linux agents on CI. So it doesn't run the tests, but it builds the klib anyway which is time consuming. - if (project.isInIdea) mingwX64() + if (addMinGw) mingwX64() linuxX64() + + val commonMain = sourceSets.getByName("commonMain") + val nativeMain = sourceSets.create("nativeMain") + nativeMain.dependsOn(commonMain) + + val iosMain = sourceSets.getByName("iosMain") + iosMain.dependsOn(nativeMain) + sourceSets.getByName("iosSimulatorArm64Main").dependsOn(iosMain) + sourceSets.getByName("iosArm64Main").dependsOn(iosMain) + sourceSets.getByName("iosX64Main").dependsOn(iosMain) + + val macosMain = sourceSets.create("macosMain") + macosMain.dependsOn(nativeMain) + sourceSets.getByName("macosX64Main").dependsOn(macosMain) + sourceSets.getByName("macosArm64Main").dependsOn(macosMain) + + val linuxMain = sourceSets.create("linuxMain") + linuxMain.dependsOn(nativeMain) + sourceSets.getByName("linuxX64Main").dependsOn(linuxMain) + + if (addMinGw) { + sourceSets.getByName("mingwX64Main").dependsOn(nativeMain) + } + } fun KotlinMultiplatformExtension.configureJsTargets() { diff --git a/compose/integrations/composable-test-cases/common/src/commonMain/kotlin/CurrentPlatform.kt b/compose/integrations/composable-test-cases/common/src/commonMain/kotlin/CurrentPlatform.kt new file mode 100644 index 00000000000..066f956c95f --- /dev/null +++ b/compose/integrations/composable-test-cases/common/src/commonMain/kotlin/CurrentPlatform.kt @@ -0,0 +1,21 @@ +import kotlin.jvm.JvmInline + +@JvmInline +value class CurrentPlatform internal constructor(internal val value: Int) { + + fun name(): String { + return when (this) { + Desktop -> "Desktop" + Web -> "Web" + Native -> "Native" + else -> "Unknown CurrentPlatform" + } + } + companion object { + val Desktop = CurrentPlatform(0) + val Web = CurrentPlatform(10) + val Native = CurrentPlatform(20) + } +} + +expect val currentPlatform: CurrentPlatform diff --git a/compose/integrations/composable-test-cases/common/src/desktopMain/kotlin/Actuals.desktop.kt b/compose/integrations/composable-test-cases/common/src/desktopMain/kotlin/Actuals.desktop.kt new file mode 100644 index 00000000000..02718227566 --- /dev/null +++ b/compose/integrations/composable-test-cases/common/src/desktopMain/kotlin/Actuals.desktop.kt @@ -0,0 +1,2 @@ + +actual val currentPlatform: CurrentPlatform = CurrentPlatform.Desktop diff --git a/compose/integrations/composable-test-cases/common/src/jsMain/kotlin/Actuals.js.kt b/compose/integrations/composable-test-cases/common/src/jsMain/kotlin/Actuals.js.kt new file mode 100644 index 00000000000..74ced3a8307 --- /dev/null +++ b/compose/integrations/composable-test-cases/common/src/jsMain/kotlin/Actuals.js.kt @@ -0,0 +1,2 @@ + +actual val currentPlatform: CurrentPlatform = CurrentPlatform.Web diff --git a/compose/integrations/composable-test-cases/common/src/nativeMain/kotlin/Actuals.native.kt b/compose/integrations/composable-test-cases/common/src/nativeMain/kotlin/Actuals.native.kt new file mode 100644 index 00000000000..9e8510fe842 --- /dev/null +++ b/compose/integrations/composable-test-cases/common/src/nativeMain/kotlin/Actuals.native.kt @@ -0,0 +1,2 @@ + +actual val currentPlatform: CurrentPlatform = CurrentPlatform.Native diff --git a/compose/integrations/composable-test-cases/settings.gradle.kts b/compose/integrations/composable-test-cases/settings.gradle.kts index 628c7bddb90..b188f4488fc 100644 --- a/compose/integrations/composable-test-cases/settings.gradle.kts +++ b/compose/integrations/composable-test-cases/settings.gradle.kts @@ -116,6 +116,9 @@ if (casesToRun.isDefault()) { module(":testcase-valueClass-lib", "testcases/valueClass/lib") module(":testcase-valueClass-main", "testcases/valueClass/main") + module(":testcase-expectActualFun-lib", "testcases/expectActualFun/lib") + module(":testcase-expectActualFun-main", "testcases/expectActualFun/main") + module(":testcase-lambdas-lib", "testcases/lambdas/lib") module(":testcase-lambdas-main", "testcases/lambdas/main") } diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/build.gradle.kts b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/build.gradle.kts new file mode 100644 index 00000000000..b96e439ee7c --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/build.gradle.kts @@ -0,0 +1,20 @@ +plugins { + kotlin("multiplatform") + id("org.jetbrains.compose") +} + +kotlin { + configureTargets() + + sourceSets { + val commonMain by getting { + dependencies { + implementation(compose.runtime) + implementation(getCommonLib()) + } + } + val commonTest by getting { + configureCommonTestDependencies() + } + } +} diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/Dependencies.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/Dependencies.kt new file mode 100644 index 00000000000..57bfb8ae06e --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/Dependencies.kt @@ -0,0 +1,66 @@ +import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember +import com.example.common.TextContainerNode +import com.example.common.TextLeafNode + +@Composable +expect fun SimpleComposable() + +@Composable +expect fun WithDefaultIntParam(i: Int = 10) + +@Composable +expect fun WithDefaultStringParam(s: String = "defaultStringValue") + +var savedComposableLambda: (@Composable () -> Unit)? = null + +expect fun TakesComposableLambda(l: @Composable () -> Unit) + +expect fun TakesComposableLambdaWithDefault(l: @Composable () -> Unit = { TextLeafNode("Default") }) + + +fun TakesComposableLambdaWithDefaultIntNotExpect(i: Int = 100, l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Common-$i", l) + } +} +expect fun TakesComposableLambdaWithDefaultInt(i: Int = 100, l: @Composable () -> Unit) + +@Composable +fun defaultStringValueComposable(): String { + return "defaultStringValueComposable" +} + +@Composable +expect fun ExpectComposableDefaultValueProvidedByAnotherComposable( + value: String = defaultStringValueComposable(), + content: @Composable (v: String) -> Unit +) + +@Composable +expect fun UseRememberInDefaultValueOfExpectFun( + value: String = remember { "defaultRememberedValue" }, + content: @Composable (v: String) -> Unit +) + +@Composable +expect fun ExpectWithTypeParameter( + value: T, + content: @Composable (T) -> Unit //= { TextLeafNode(value.toString()) } +) + +@Composable +expect fun ExpectWithTypeParameterAndDefaultLambda( + value: T, + transform: (T) -> T = { it } +) + +@Composable +expect fun ExpectWithTypeParameterAndDefaultComposableLambda( + value: T, + content: @Composable (T) -> Unit = createDefaultContent(value) +) + +fun createDefaultContent(value: T): @Composable (T) -> Unit { + return { TextLeafNode(value.toString()) } +} diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/Actuals.desktop.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/Actuals.desktop.kt new file mode 100644 index 00000000000..2ab0cfe78a0 --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/Actuals.desktop.kt @@ -0,0 +1,82 @@ +import androidx.compose.runtime.Composable +import com.example.common.TextContainerNode +import com.example.common.TextLeafNode + +@Composable +actual fun SimpleComposable() { + TextLeafNode("SimpleComposable-Desktop") +} + +@Composable +actual fun WithDefaultIntParam(i: Int) { + TextLeafNode("SimpleComposable-Desktop-$i") +} + +@Composable +actual fun WithDefaultStringParam(s: String) { + TextLeafNode("SimpleComposable-Desktop-$s") +} + +actual fun TakesComposableLambda(l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Desktop", l) + } +} + +actual fun TakesComposableLambdaWithDefault(l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Desktop", l) + } +} + +actual fun TakesComposableLambdaWithDefaultInt(i: Int, l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Desktop-$i", l) + } +} + +@Composable +actual fun ExpectComposableDefaultValueProvidedByAnotherComposable( + value: String, + content: @Composable (v: String) -> Unit +) { + content("Desktop-$value") +} + +@Composable +actual fun UseRememberInDefaultValueOfExpectFun( + value: String, + content: @Composable (v: String) -> Unit +) { + content("Desktop-$value") +} + +@Composable +actual fun ExpectWithTypeParameter( + value: T, + content: @Composable (T) -> Unit +) { + TextContainerNode("Desktop") { + content(value) + } +} + +@Composable +actual fun ExpectWithTypeParameterAndDefaultLambda( + value: T, + transform: (T) -> T +) { + TextContainerNode("Desktop") { + TextLeafNode(transform(value).toString()) + } +} + +@Composable +actual fun ExpectWithTypeParameterAndDefaultComposableLambda( + value: T, + content: @Composable (T) -> Unit +) { + TextContainerNode("Desktop") { + content(value) + } +} diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/Actuals.js.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/Actuals.js.kt new file mode 100644 index 00000000000..550d18af2c8 --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/Actuals.js.kt @@ -0,0 +1,83 @@ +import androidx.compose.runtime.Composable +import com.example.common.TextContainerNode +import com.example.common.TextLeafNode + +@Composable +actual fun SimpleComposable() { + TextLeafNode("SimpleComposable-Web") +} + +@Composable +actual fun WithDefaultIntParam(i: Int) { + TextLeafNode("SimpleComposable-Web-$i") +} + +@Composable +actual fun WithDefaultStringParam(s: String) { + TextLeafNode("SimpleComposable-Web-$s") +} + +actual fun TakesComposableLambda(l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Web", l) + } +} + +actual fun TakesComposableLambdaWithDefault(l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Web", l) + } +} + +actual fun TakesComposableLambdaWithDefaultInt(i: Int, l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Web-$i", l) + } +} + +@Composable +actual fun ExpectComposableDefaultValueProvidedByAnotherComposable( + value: String, + content: @Composable (v: String) -> Unit +) { + content("Web-$value") +} + + +@Composable +actual fun UseRememberInDefaultValueOfExpectFun( + value: String, + content: @Composable (v: String) -> Unit +) { + content("Web-$value") +} + +@Composable +actual fun ExpectWithTypeParameter( + value: T, + content: @Composable (T) -> Unit +) { + TextContainerNode("Web") { + content(value) + } +} + +@Composable +actual fun ExpectWithTypeParameterAndDefaultLambda( + value: T, + transform: (T) -> T +) { + TextContainerNode("Web") { + TextLeafNode(transform(value).toString()) + } +} + +@Composable +actual fun ExpectWithTypeParameterAndDefaultComposableLambda( + value: T, + content: @Composable (T) -> Unit +) { + TextContainerNode("Web") { + content(value) + } +} diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/Actuals.native.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/Actuals.native.kt new file mode 100644 index 00000000000..c7430b86458 --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/Actuals.native.kt @@ -0,0 +1,82 @@ +import androidx.compose.runtime.Composable +import com.example.common.TextContainerNode +import com.example.common.TextLeafNode + +@Composable +actual fun SimpleComposable() { + TextLeafNode("SimpleComposable-Native") +} + +@Composable +actual fun WithDefaultIntParam(i: Int) { + TextLeafNode("SimpleComposable-Native-$i") +} + +@Composable +actual fun WithDefaultStringParam(s: String) { + TextLeafNode("SimpleComposable-Native-$s") +} + +actual fun TakesComposableLambda(l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Native", l) + } +} + +actual fun TakesComposableLambdaWithDefault(l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Native", l) + } +} + +actual fun TakesComposableLambdaWithDefaultInt(i: Int, l: @Composable () -> Unit) { + savedComposableLambda = { + TextContainerNode("Native-$i", l) + } +} + +@Composable +actual fun ExpectComposableDefaultValueProvidedByAnotherComposable( + value: String, + content: @Composable (v: String) -> Unit +) { + content("Native-$value") +} + +@Composable +actual fun UseRememberInDefaultValueOfExpectFun( + value: String, + content: @Composable (v: String) -> Unit +) { + content("Native-$value") +} + +@Composable +actual fun ExpectWithTypeParameter( + value: T, + content: @Composable (T) -> Unit +) { + TextContainerNode("Native") { + content(value) + } +} + +@Composable +actual fun ExpectWithTypeParameterAndDefaultLambda( + value: T, + transform: (T) -> T +) { + TextContainerNode("Native") { + TextLeafNode(transform(value).toString()) + } +} + +@Composable +actual fun ExpectWithTypeParameterAndDefaultComposableLambda( + value: T, + content: @Composable (T) -> Unit +) { + TextContainerNode("Native") { + content(value) + } +} diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/main/build.gradle.kts b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/build.gradle.kts new file mode 100644 index 00000000000..d49878c7d22 --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/build.gradle.kts @@ -0,0 +1,21 @@ +plugins { + kotlin("multiplatform") + id("org.jetbrains.compose") +} + +kotlin { + configureTargets() + + sourceSets { + val commonMain by getting { + dependencies { + implementation(compose.runtime) + implementation(getCommonLib()) + implementation(getLibDependencyForMain()) + } + } + val commonTest by getting { + configureCommonTestDependencies() + } + } +} diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt new file mode 100644 index 00000000000..74d06ea519a --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt @@ -0,0 +1,142 @@ +import com.example.common.TextLeafNode +import com.example.common.composeText +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.runTest +import kotlin.test.Test +import kotlin.test.assertEquals + +@OptIn(ExperimentalCoroutinesApi::class) +class TestExpectActuals { + + @Test + fun simpleExpectComposable() = runTest { + val root = composeText { + SimpleComposable() + } + + assertEquals("root:{SimpleComposable-${currentPlatform.name()}}", root.dump()) + } + + @Test + fun testWithDefaultIntParam() = runTest { + val root = composeText { + WithDefaultIntParam() + } + + assertEquals("root:{SimpleComposable-${currentPlatform.name()}-10}", root.dump()) + } + + @Test + fun testWithDefaultStringParam() = runTest { + val root = composeText { + WithDefaultStringParam() + } + + assertEquals("root:{SimpleComposable-${currentPlatform.name()}-defaultStringValue}", root.dump()) + } + + @Test + fun testExpectTakesComposableLambda() = runTest { + savedComposableLambda = null + + TakesComposableLambda { + TextLeafNode("12345") + } + val root = composeText { + savedComposableLambda!!.invoke() + } + + assertEquals("root:{${currentPlatform.name()}:{12345}}", root.dump()) + } + + @Test + fun testTakesComposableLambdaWithDefaultIntNotExpect() = runTest { + savedComposableLambda = null + + TakesComposableLambdaWithDefaultIntNotExpect { + TextLeafNode("ABC") + } + + val root = composeText { + savedComposableLambda!!.invoke() + } + + assertEquals("root:{Common-100:{ABC}}", root.dump()) + } + + @Test + fun testTakesComposableLambdaWithDefaultInt() = runTest { + savedComposableLambda = null + + TakesComposableLambdaWithDefaultInt { + TextLeafNode("ABC") + } + + val root = composeText { + savedComposableLambda!!.invoke() + } + + assertEquals("root:{${currentPlatform.name()}-100:{ABC}}", root.dump()) + } + + @Test + fun testTakesComposableLambdaWithDefault() = runTest { + savedComposableLambda = null + + TakesComposableLambdaWithDefault() + + val root = composeText { + savedComposableLambda!!.invoke() + } + + assertEquals("root:{${currentPlatform.name()}:{Default}}", root.dump()) + } + + @Test + fun TestExpectComposableDefaultValueProvidedByAnotherComposable() = runTest { + val root = composeText { + ExpectComposableDefaultValueProvidedByAnotherComposable { + TextLeafNode(it) + } + } + assertEquals("root:{${currentPlatform.name()}-defaultStringValueComposable}", root.dump()) + } + + @Test + fun TestUseRememberInDefaultValueOfExpectFun() = runTest { + val root = composeText { + UseRememberInDefaultValueOfExpectFun { + TextLeafNode(it) + } + } + assertEquals("root:{${currentPlatform.name()}-defaultRememberedValue}", root.dump()) + } + + @Test + fun TestExpectWithTypeParameter() = runTest { + val root = composeText { + ExpectWithTypeParameter("TTT") { s -> + TextLeafNode(s) + } + } + assertEquals("root:{${currentPlatform.name()}:{TTT}}", root.dump()) + } + + @Test + fun testExpectWithTypeParameterAndDefaultLambda() = runTest { + val root = composeText { + ExpectWithTypeParameterAndDefaultLambda("3.1415") + } + assertEquals("root:{${currentPlatform.name()}:{3.1415}}", root.dump()) + } + + @Test + fun TestExpectWithTypeParameterAndDefaultValue() = runTest { + val root = composeText { + ExpectWithTypeParameterAndDefaultComposableLambda("QWERTY") { s -> + TextLeafNode(s) + } + } + assertEquals("root:{${currentPlatform.name()}:{QWERTY}}", root.dump()) + } +} From 6f8276eac71c5e6dd933861a7f1a676b74970213 Mon Sep 17 00:00:00 2001 From: Oleksandr Karpovich Date: Tue, 7 Mar 2023 11:47:33 +0100 Subject: [PATCH 2/3] refactoring: move expect/actual functions to a separete package For some reason desktop(jvm-target) fails to resolve symbols when expect declarations are in the root (src/kotlin) w/o a package --- .../lib/src/commonMain/kotlin/{ => my/abc}/Dependencies.kt | 2 ++ .../lib/src/desktopMain/kotlin/{ => my/abc}/Actuals.desktop.kt | 2 ++ .../lib/src/jsMain/kotlin/{ => my/abc}/Actuals.js.kt | 2 ++ .../lib/src/nativeMain/kotlin/{ => my/abc}/Actuals.native.kt | 2 ++ .../main/src/commonTest/kotlin/TestExpectActuals.kt | 1 + 5 files changed, 9 insertions(+) rename compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/{ => my/abc}/Dependencies.kt (99%) rename compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/{ => my/abc}/Actuals.desktop.kt (99%) rename compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/{ => my/abc}/Actuals.js.kt (99%) rename compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/{ => my/abc}/Actuals.native.kt (99%) diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/Dependencies.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/my/abc/Dependencies.kt similarity index 99% rename from compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/Dependencies.kt rename to compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/my/abc/Dependencies.kt index 57bfb8ae06e..a022ff4e275 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/Dependencies.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/my/abc/Dependencies.kt @@ -1,3 +1,5 @@ +package my.abc + import androidx.compose.runtime.Composable import androidx.compose.runtime.remember import com.example.common.TextContainerNode diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/Actuals.desktop.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/my/abc/Actuals.desktop.kt similarity index 99% rename from compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/Actuals.desktop.kt rename to compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/my/abc/Actuals.desktop.kt index 2ab0cfe78a0..d1a8ae7bb6c 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/Actuals.desktop.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/my/abc/Actuals.desktop.kt @@ -1,3 +1,5 @@ +package my.abc + import androidx.compose.runtime.Composable import com.example.common.TextContainerNode import com.example.common.TextLeafNode diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/Actuals.js.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/my/abc/Actuals.js.kt similarity index 99% rename from compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/Actuals.js.kt rename to compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/my/abc/Actuals.js.kt index 550d18af2c8..1355a73c428 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/Actuals.js.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/my/abc/Actuals.js.kt @@ -1,3 +1,5 @@ +package my.abc + import androidx.compose.runtime.Composable import com.example.common.TextContainerNode import com.example.common.TextLeafNode diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/Actuals.native.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/my/abc/Actuals.native.kt similarity index 99% rename from compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/Actuals.native.kt rename to compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/my/abc/Actuals.native.kt index c7430b86458..99ba6231160 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/Actuals.native.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/my/abc/Actuals.native.kt @@ -1,3 +1,5 @@ +package my.abc + import androidx.compose.runtime.Composable import com.example.common.TextContainerNode import com.example.common.TextLeafNode diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt index 74d06ea519a..4299632d062 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt @@ -1,4 +1,5 @@ import com.example.common.TextLeafNode +import my.abc.* import com.example.common.composeText import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.test.runTest From e29fed91a536390626b2858add8e26555ddf99d9 Mon Sep 17 00:00:00 2001 From: Oleksandr Karpovich Date: Wed, 8 Mar 2023 12:57:53 +0100 Subject: [PATCH 3/3] add more test cases for expect/actual fun with default values --- .../commonMain/kotlin/my/abc/Dependencies.kt | 53 +++++++ .../kotlin/my/abc/Actuals.desktop.kt | 68 ++++++++- .../src/jsMain/kotlin/my/abc/Actuals.js.kt | 66 ++++++++ .../kotlin/my/abc/Actuals.native.kt | 66 ++++++++ .../commonTest/kotlin/TestExpectActuals.kt | 33 +++- .../src/commonTest/kotlin/TestExpectClass.kt | 118 +++++++++++++++ .../kotlin/TestOverrideDefaultValues.kt | 141 ++++++++++++++++++ 7 files changed, 537 insertions(+), 8 deletions(-) create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectClass.kt create mode 100644 compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestOverrideDefaultValues.kt diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/my/abc/Dependencies.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/my/abc/Dependencies.kt index a022ff4e275..85f9924c740 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/my/abc/Dependencies.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/commonMain/kotlin/my/abc/Dependencies.kt @@ -66,3 +66,56 @@ expect fun ExpectWithTypeParameterAndDefaultComposableLambda( fun createDefaultContent(value: T): @Composable (T) -> Unit { return { TextLeafNode(value.toString()) } } + +@Composable +expect fun ExpectWithTypeParameterInReturnAndDefaultComposableLambda( + value: T, + calculate: @Composable (T) -> T = { value } +): T + +expect class ExpectClass() { + + @Composable + fun ExpectComposableFunWithDefaultInt(i: Int = 11011) +} + +expect class ExpectClassWithString() { + + @Composable + fun ExpectComposableFunWithDefaultComposableLambda( + s: String, + transform: @Composable (String) -> String = { s } + ) +} + +expect class ExpectClassWithStringProperty constructor(s: String) { + + val property: String + + @Composable + fun ExpectComposableFunWithDefaultComposableLambda( + transform: @Composable (String) -> String = { property } + ) +} + +expect class ExpectClassWithT() { + + @Composable + fun ExpectComposableFunWithDefaultComposableLambda(t: T, transform: @Composable (T) -> T = { t }) +} + +expect class ExpectClassWithTProp(t: T) { + + val tVal: T + + @Composable + fun ExpectComposableFunWithDefaultComposableLambda(transform: @Composable (T) -> T = { tVal }) +} + +expect class ExpectClassWithTProp2(t: T) { + + val tVal: T + + @Composable + fun ExpectComposableFunWithDefaultComposableLambda(t: T = tVal) +} \ No newline at end of file diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/my/abc/Actuals.desktop.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/my/abc/Actuals.desktop.kt index d1a8ae7bb6c..485b785f03d 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/my/abc/Actuals.desktop.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/desktopMain/kotlin/my/abc/Actuals.desktop.kt @@ -42,7 +42,7 @@ actual fun ExpectComposableDefaultValueProvidedByAnotherComposable( value: String, content: @Composable (v: String) -> Unit ) { - content("Desktop-$value") + content("Desktop-$value") } @Composable @@ -82,3 +82,69 @@ actual fun ExpectWithTypeParameterAndDefaultComposableLambda( content(value) } } + +@Composable +actual fun ExpectWithTypeParameterInReturnAndDefaultComposableLambda( + value: T, + calculate: @Composable (T) -> T +): T { + return calculate(value) +} + +actual class ExpectClass actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultInt(i: Int) { + TextLeafNode("Desktop(i = $i)") + } +} + +actual class ExpectClassWithString actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda( + s: String, transform: @Composable (String) -> String + ) { + TextLeafNode("Desktop(s = ${transform(s)})") + } +} + +actual class ExpectClassWithStringProperty actual constructor(s: String) { + + actual val property: String = s + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda( + transform: @Composable (String) -> String + ) { + TextLeafNode("Desktop(s = ${transform(property)})") + } +} + +actual class ExpectClassWithT actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(t: T, transform: @Composable (T) -> T) { + TextLeafNode("Desktop(t = ${transform(t)})") + } +} + +actual class ExpectClassWithTProp actual constructor(t: T) { + + actual val tVal: T = t + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(transform: @Composable (T) -> T) { + TextLeafNode("Desktop(tProp = ${transform(tVal)})") + } +} + +actual class ExpectClassWithTProp2 actual constructor(t: T) { + + actual val tVal: T = t + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(t: T) { + TextLeafNode("Desktop(tProp = $t)") + } +} \ No newline at end of file diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/my/abc/Actuals.js.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/my/abc/Actuals.js.kt index 1355a73c428..5623a1b5a42 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/my/abc/Actuals.js.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/jsMain/kotlin/my/abc/Actuals.js.kt @@ -83,3 +83,69 @@ actual fun ExpectWithTypeParameterAndDefaultComposableLambda( content(value) } } + +@Composable +actual fun ExpectWithTypeParameterInReturnAndDefaultComposableLambda( + value: T, + calculate: @Composable (T) -> T +): T { + return calculate(value) +} + +actual class ExpectClass actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultInt(i: Int) { + TextLeafNode("Web(i = $i)") + } +} + +actual class ExpectClassWithString actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda( + s: String, transform: @Composable (String) -> String + ) { + TextLeafNode("Web(s = ${transform(s)})") + } +} + +actual class ExpectClassWithStringProperty actual constructor(s: String) { + + actual val property: String = s + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda( + transform: @Composable (String) -> String + ) { + TextLeafNode("Web(s = ${transform(property)})") + } +} + +actual class ExpectClassWithT actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(t: T, transform: @Composable (T) -> T) { + TextLeafNode("Web(t = ${transform(t)})") + } +} + +actual class ExpectClassWithTProp actual constructor(t: T) { + + actual val tVal: T = t + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(transform: @Composable (T) -> T) { + TextLeafNode("Web(tProp = ${transform(tVal)})") + } +} + +actual class ExpectClassWithTProp2 actual constructor(t: T) { + + actual val tVal: T = t + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(t: T) { + TextLeafNode("Web(tProp = $t)") + } +} \ No newline at end of file diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/my/abc/Actuals.native.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/my/abc/Actuals.native.kt index 99ba6231160..93918e259d8 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/my/abc/Actuals.native.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/lib/src/nativeMain/kotlin/my/abc/Actuals.native.kt @@ -82,3 +82,69 @@ actual fun ExpectWithTypeParameterAndDefaultComposableLambda( content(value) } } + +@Composable +actual fun ExpectWithTypeParameterInReturnAndDefaultComposableLambda( + value: T, + calculate: @Composable (T) -> T +): T { + return calculate(value) +} + +actual class ExpectClass actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultInt(i: Int) { + TextLeafNode("Native(i = $i)") + } +} + +actual class ExpectClassWithString actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda( + s: String, transform: @Composable (String) -> String + ) { + TextLeafNode("Native(s = ${transform(s)})") + } +} + +actual class ExpectClassWithStringProperty actual constructor(s: String) { + + actual val property: String = s + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda( + transform: @Composable (String) -> String + ) { + TextLeafNode("Native(s = ${transform(property)})") + } +} + +actual class ExpectClassWithT actual constructor() { + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(t: T, transform: @Composable (T) -> T) { + TextLeafNode("Native(t = ${transform(t)})") + } +} + +actual class ExpectClassWithTProp actual constructor(t: T) { + + actual val tVal: T = t + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(transform: @Composable (T) -> T) { + TextLeafNode("Native(tProp = ${transform(tVal)})") + } +} + +actual class ExpectClassWithTProp2 actual constructor(t: T) { + + actual val tVal: T = t + + @Composable + actual fun ExpectComposableFunWithDefaultComposableLambda(t: T) { + TextLeafNode("Native(tProp = $t)") + } +} \ No newline at end of file diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt index 4299632d062..e7992858e83 100644 --- a/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectActuals.kt @@ -1,7 +1,9 @@ +import androidx.compose.runtime.mutableStateOf import com.example.common.TextLeafNode import my.abc.* import com.example.common.composeText import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.Job import kotlinx.coroutines.test.runTest import kotlin.test.Test import kotlin.test.assertEquals @@ -94,7 +96,7 @@ class TestExpectActuals { } @Test - fun TestExpectComposableDefaultValueProvidedByAnotherComposable() = runTest { + fun testExpectComposableDefaultValueProvidedByAnotherComposable() = runTest { val root = composeText { ExpectComposableDefaultValueProvidedByAnotherComposable { TextLeafNode(it) @@ -104,7 +106,7 @@ class TestExpectActuals { } @Test - fun TestUseRememberInDefaultValueOfExpectFun() = runTest { + fun testUseRememberInDefaultValueOfExpectFun() = runTest { val root = composeText { UseRememberInDefaultValueOfExpectFun { TextLeafNode(it) @@ -114,7 +116,7 @@ class TestExpectActuals { } @Test - fun TestExpectWithTypeParameter() = runTest { + fun testExpectWithTypeParameter() = runTest { val root = composeText { ExpectWithTypeParameter("TTT") { s -> TextLeafNode(s) @@ -132,12 +134,29 @@ class TestExpectActuals { } @Test - fun TestExpectWithTypeParameterAndDefaultValue() = runTest { + fun testExpectWithTypeParameterAndDefaultValue() = runTest { val root = composeText { - ExpectWithTypeParameterAndDefaultComposableLambda("QWERTY") { s -> - TextLeafNode(s) - } + ExpectWithTypeParameterAndDefaultComposableLambda("QWERTY") } assertEquals("root:{${currentPlatform.name()}:{QWERTY}}", root.dump()) } + + @Test + fun testExpectWithTypeParameterInReturnAndDefaultComposableLambda() = runTest { + val argument = mutableStateOf("aAbBcCdDeE") + val job = Job() + + val root = composeText(coroutineContext + job) { + val text = ExpectWithTypeParameterInReturnAndDefaultComposableLambda(argument.value) + TextLeafNode(text) + } + + assertEquals("root:{aAbBcCdDeE}", root.dump()) + argument.value = "1123581321" + + testScheduler.advanceUntilIdle() + assertEquals("root:{1123581321}", root.dump()) + + job.cancel() + } } diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectClass.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectClass.kt new file mode 100644 index 00000000000..c5dfc188863 --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestExpectClass.kt @@ -0,0 +1,118 @@ +import androidx.compose.runtime.remember +import com.example.common.composeText +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.runTest +import my.abc.* +import kotlin.test.Test +import kotlin.test.assertEquals + +@OptIn(ExperimentalCoroutinesApi::class) +class TestExpectClass { + + @Test + fun testExpectClass() = runTest { + val root = composeText { + val instance = remember { ExpectClass() } + instance.ExpectComposableFunWithDefaultInt() + } + + assertEquals("root:{${currentPlatform.name()}(i = 11011)}", root.dump()) + } + + @Test + fun testExpectClassOverrideDefault() = runTest { + val root = composeText { + val instance = remember { ExpectClass() } + instance.ExpectComposableFunWithDefaultInt(22122) + } + + assertEquals("root:{${currentPlatform.name()}(i = 22122)}", root.dump()) + } + + @Test + fun testExpectClassWithString() = runTest { + val root = composeText { + val instance = remember { ExpectClassWithString() } + instance.ExpectComposableFunWithDefaultComposableLambda("tTt") + } + + assertEquals("root:{${currentPlatform.name()}(s = tTt)}", root.dump()) + } + + @Test + fun testExpectClassWithStringOverrideDefault() = runTest { + val root = composeText { + val instance = remember { ExpectClassWithString() } + instance.ExpectComposableFunWithDefaultComposableLambda("tTt") { + it.replace('T', 'A') + } + } + + assertEquals("root:{${currentPlatform.name()}(s = tAt)}", root.dump()) + } + + @Test + fun testExpectClassWithStringProperty() = runTest { + val root = composeText { + val instance = remember { ExpectClassWithStringProperty("aeouiyu") } + instance.ExpectComposableFunWithDefaultComposableLambda() + } + + assertEquals("root:{${currentPlatform.name()}(s = aeouiyu)}", root.dump()) + } + + @Test + fun testExpectClassWithT() = runTest { + val root = composeText { + val instance = remember { ExpectClassWithT() } + instance.ExpectComposableFunWithDefaultComposableLambda("tTt") + } + + assertEquals("root:{${currentPlatform.name()}(t = tTt)}", root.dump()) + } + + @Test + fun testExpectClassWithTProp() = runTest { + val root = composeText { + val instance = remember { ExpectClassWithTProp("genby-[eqkj") } + instance.ExpectComposableFunWithDefaultComposableLambda() + } + + assertEquals("root:{${currentPlatform.name()}(tProp = genby-[eqkj)}", root.dump()) + } + + @Test + fun testExpectClassWithTPropOverrideDefault() = runTest { + val root = composeText { + val instance = remember { ExpectClassWithTProp("genby-[eqkj") } + instance.ExpectComposableFunWithDefaultComposableLambda { + "$it!!!" + } + } + + assertEquals( + "root:{${currentPlatform.name()}(tProp = genby-[eqkj!!!)}", + root.dump() + ) + } + + @Test + fun testExpectClassWithTProp2() = runTest { + val root = composeText { + val instance = remember { ExpectClassWithTProp2("RWGFY") } + instance.ExpectComposableFunWithDefaultComposableLambda() + } + + assertEquals("root:{${currentPlatform.name()}(tProp = RWGFY)}", root.dump()) + } + + @Test + fun testExpectClassWithTProp2OverrideDefault() = runTest { + val root = composeText { + val instance = remember { ExpectClassWithTProp2("RWGFY") } + instance.ExpectComposableFunWithDefaultComposableLambda("COTTON!") + } + + assertEquals("root:{${currentPlatform.name()}(tProp = COTTON!)}", root.dump()) + } +} \ No newline at end of file diff --git a/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestOverrideDefaultValues.kt b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestOverrideDefaultValues.kt new file mode 100644 index 00000000000..a2ccd096245 --- /dev/null +++ b/compose/integrations/composable-test-cases/testcases/expectActualFun/main/src/commonTest/kotlin/TestOverrideDefaultValues.kt @@ -0,0 +1,141 @@ +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import com.example.common.TextContainerNode +import com.example.common.TextLeafNode +import com.example.common.composeText +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.Job +import kotlinx.coroutines.test.runTest +import my.abc.* +import kotlin.test.Test +import kotlin.test.assertEquals + +@OptIn(ExperimentalCoroutinesApi::class) +class TestOverrideDefaultValues { + + @Test + fun testWithDefaultIntParam() = runTest { + val root = composeText { + WithDefaultIntParam(500) + } + + assertEquals("root:{SimpleComposable-${currentPlatform.name()}-500}", root.dump()) + } + + @Test + fun testWithDefaultStringParam() = runTest { + val root = composeText { + WithDefaultStringParam("OverrideDefaultString") + } + + assertEquals("root:{SimpleComposable-${currentPlatform.name()}-OverrideDefaultString}", root.dump()) + } + + @Test + fun testTakesComposableLambdaWithDefaultIntNotExpect() = runTest { + savedComposableLambda = null + + TakesComposableLambdaWithDefaultIntNotExpect(123123) { + TextLeafNode("ABC") + } + + val root = composeText { + savedComposableLambda!!.invoke() + } + + assertEquals("root:{Common-123123:{ABC}}", root.dump()) + } + + @Test + fun testTakesComposableLambdaWithDefaultInt() = runTest { + savedComposableLambda = null + + TakesComposableLambdaWithDefaultInt(56789) { + TextLeafNode("ABC") + } + + val root = composeText { + savedComposableLambda!!.invoke() + } + + assertEquals("root:{${currentPlatform.name()}-56789:{ABC}}", root.dump()) + } + + + @Test + fun testTakesComposableLambdaWithDefault() = runTest { + savedComposableLambda = null + + TakesComposableLambdaWithDefault { + TextLeafNode("OverrideDefault") + } + + val root = composeText { + savedComposableLambda!!.invoke() + } + + assertEquals("root:{${currentPlatform.name()}:{OverrideDefault}}", root.dump()) + } + + @Test + fun testExpectComposableDefaultValueProvidedByAnotherComposable() = runTest { + val root = composeText { + ExpectComposableDefaultValueProvidedByAnotherComposable("OverrideDefault") { + TextLeafNode("$it+postfix") + } + } + assertEquals("root:{${currentPlatform.name()}-OverrideDefault+postfix}", root.dump()) + } + + @Test + fun testUseRememberInDefaultValueOfExpectFun() = runTest { + val root = composeText { + UseRememberInDefaultValueOfExpectFun(remember { "OverrideRememberDefault" }) { + TextLeafNode(it) + } + } + assertEquals("root:{${currentPlatform.name()}-OverrideRememberDefault}", root.dump()) + } + + @Test + fun testExpectWithTypeParameterAndDefaultLambda() = runTest { + val root = composeText { + ExpectWithTypeParameterAndDefaultLambda("3.1415") { + "π=$it" + } + } + assertEquals("root:{${currentPlatform.name()}:{π=3.1415}}", root.dump()) + } + + @Test + fun testExpectWithTypeParameterAndDefaultValue() = runTest { + val root = composeText { + ExpectWithTypeParameterAndDefaultComposableLambda("QWERTY") { s -> + TextContainerNode("parent") { + TextLeafNode(s) + } + } + } + assertEquals("root:{${currentPlatform.name()}:{parent:{QWERTY}}}", root.dump()) + } + + @Test + fun testExpectWithTypeParameterInReturnAndDefaultComposableLambda() = runTest { + val argument = mutableStateOf("aAbBcCdDeE") + val job = Job() + + val root = composeText(coroutineContext + job) { + val text = ExpectWithTypeParameterInReturnAndDefaultComposableLambda(argument.value) { + it + " " + it.reversed() + } + TextLeafNode(text) + } + + assertEquals("root:{aAbBcCdDeE EeDdCcBbAa}", root.dump()) + argument.value = "1123581321" + + testScheduler.advanceUntilIdle() + assertEquals("root:{1123581321 1231853211}", root.dump()) + job.cancel() + } +} \ No newline at end of file