[resources] Update tests

components/resources/library/src/commonTest/kotlin/org/jetbrains/compose/resources/ComposeResourceTest.kt

@@ -12,7 +12,7 @@ import kotlin.test.*
 class ComposeResourceTest {
 
     init {
-        dropStringsCache()
+        dropStringItemsCache()
         dropImageCache()
         getResourceEnvironment = ::getTestEnvironment
     }
@@ -71,7 +71,7 @@ class ComposeResourceTest {
             ) {
                 str = stringResource(res)
                 Text(str)
-                Text(stringArrayResource(TestStringResource("str_arr")).joinToString())
+                Text(stringArrayResource(TestStringArrayResource("str_arr")).joinToString())
             }
         }
         waitForIdle()
@@ -82,9 +82,25 @@ class ComposeResourceTest {
         res = TestStringResource("app_name")
         waitForIdle()
         assertEquals(str, "Compose Resources App")
+        res = TestStringResource("hello")
+        waitForIdle()
+        assertEquals(str, "\uD83D\uDE0A Hello world!")
+        res = TestStringResource("app_name")
+        waitForIdle()
+        assertEquals(str, "Compose Resources App")
+        res = TestStringResource("hello")
+        waitForIdle()
+        assertEquals(str, "\uD83D\uDE0A Hello world!")
+        res = TestStringResource("app_name")
+        waitForIdle()
+        assertEquals(str, "Compose Resources App")
 
         assertEquals(
-            expected = listOf("strings.xml"), //just one string.xml read
+            expected = listOf(
+                "strings.cvr/314-44",
+                "strings.cvr/211-47",
+                "strings.cvr/359-37"
+            ), //only three different
             actual = testResourceReader.readPaths
         )
     }
@@ -100,7 +116,7 @@ class ComposeResourceTest {
                 app_name = stringResource(TestStringResource("app_name"))
                 accentuated_characters = stringResource(TestStringResource("accentuated_characters"))
                 str_template = stringResource(TestStringResource("str_template"), "test-name", 42)
-                str_arr = stringArrayResource(TestStringResource("str_arr"))
+                str_arr = stringArrayResource(TestStringArrayResource("str_arr"))
             }
         }
         waitForIdle()
@@ -141,7 +157,7 @@ class ComposeResourceTest {
             "Hello, test-name! You have 42 new messages.",
             getString(TestStringResource("str_template"), "test-name", 42)
         )
-        assertEquals(listOf("item 1", "item 2", "item 3"), getStringArray(TestStringResource("str_arr")))
+        assertEquals(listOf("item 1", "item 2", "item 3"), getStringArray(TestStringArrayResource("str_arr")))
     }
 
     @Test
@@ -253,32 +269,18 @@ class ComposeResourceTest {
 
     @Test
     fun testReadFileResource() = runTest {
-        val bytes = readResourceBytes("strings.xml")
+        val bytes = readResourceBytes("strings.cvr")
         assertEquals(
             """
-                <resources>
-                    <string name="app_name">Compose Resources App</string>
-                    <string name="hello">😊 Hello world!</string>
-                    <string name="accentuated_characters">Créer une table</string>
-                    <string name="str_template">Hello, %1${'$'}s! You have %2${'$'}d new messages.</string>
-                    <string-array name="str_arr">
-                        <item>item 1</item>
-                        <item>item 2</item>
-                        <item>item 3</item>
-                    </string-array>
-                    <plurals name="plurals">
-                        <item quantity="one">one</item>
-                        <item quantity="other">other</item>
-                    </plurals>
-                    <plurals name="another_plurals">
-                        <item quantity="one">another one</item>
-                        <item quantity="other">another other</item>
-                    </plurals>
-                    <plurals name="messages">
-                        <item quantity="one">%1${'$'}d message for %2${'$'}s</item>
-                        <item quantity="other">%1${'$'}d messages for %2${'$'}s</item>
-                    </plurals>
-                </resources>
+                version:0
+                plurals|another_plurals|ONE:YW5vdGhlciBvbmU=,OTHER:YW5vdGhlciBvdGhlcg==
+                plurals|messages|ONE:JTEkZCBtZXNzYWdlIGZvciAlMiRz,OTHER:JTEkZCBtZXNzYWdlcyBmb3IgJTIkcw==
+                plurals|plurals|ONE:b25l,OTHER:b3RoZXI=
+                string-array|str_arr|aXRlbSAx,aXRlbSAy,aXRlbSAz
+                string|accentuated_characters|Q3LDqWVyIHVuZSB0YWJsZQ==
+                string|app_name|Q29tcG9zZSBSZXNvdXJjZXMgQXBw
+                string|hello|8J+YiiBIZWxsbyB3b3JsZCE=
+                string|str_template|SGVsbG8sICUxJHMhIFlvdSBoYXZlICUyJGQgbmV3IG1lc3NhZ2VzLg==
                 
             """.trimIndent(),
             bytes.decodeToString()

components/resources/library/src/commonTest/kotlin/org/jetbrains/compose/resources/ResourceTest.kt

@@ -27,11 +27,11 @@ class ResourceTest {
         val resource = DrawableResource(
             id = "ImageResource:test",
             items = setOf(
-                ResourceItem(setOf(), "default"),
-                ResourceItem(setOf(LanguageQualifier("en")), "en"),
-                ResourceItem(setOf(LanguageQualifier("en"), RegionQualifier("US"), XHDPI), "en-rUS-xhdpi"),
-                ResourceItem(setOf(LanguageQualifier("fr"), LIGHT), "fr-light"),
-                ResourceItem(setOf(DARK), "dark"),
+                ResourceItem(setOf(), "default", -1, -1),
+                ResourceItem(setOf(LanguageQualifier("en")), "en", -1, -1),
+                ResourceItem(setOf(LanguageQualifier("en"), RegionQualifier("US"), XHDPI), "en-rUS-xhdpi", -1, -1),
+                ResourceItem(setOf(LanguageQualifier("fr"), LIGHT), "fr-light", -1, -1),
+                ResourceItem(setOf(DARK), "dark", -1, -1),
             )
         )
         fun env(lang: String, reg: String, theme: ThemeQualifier, density: DensityQualifier) = ResourceEnvironment(
@@ -42,46 +42,46 @@ class ResourceTest {
         )
         assertEquals(
             "en-rUS-xhdpi",
-            resource.getPathByEnvironment(env("en", "US", DARK, XXHDPI))
+            resource.getResourceItemByEnvironment(env("en", "US", DARK, XXHDPI)).path
         )
         assertEquals(
             "en",
-            resource.getPathByEnvironment(env("en", "IN", LIGHT, LDPI))
+            resource.getResourceItemByEnvironment(env("en", "IN", LIGHT, LDPI)).path
         )
         assertEquals(
             "default",
-            resource.getPathByEnvironment(env("ch", "", LIGHT, MDPI))
+            resource.getResourceItemByEnvironment(env("ch", "", LIGHT, MDPI)).path
         )
         assertEquals(
             "dark",
-            resource.getPathByEnvironment(env("ch", "", DARK, MDPI))
+            resource.getResourceItemByEnvironment(env("ch", "", DARK, MDPI)).path
         )
         assertEquals(
             "fr-light",
-            resource.getPathByEnvironment(env("fr", "", DARK, MDPI))
+            resource.getResourceItemByEnvironment(env("fr", "", DARK, MDPI)).path
         )
         assertEquals(
             "fr-light",
-            resource.getPathByEnvironment(env("fr", "IN", LIGHT, MDPI))
+            resource.getResourceItemByEnvironment(env("fr", "IN", LIGHT, MDPI)).path
         )
         assertEquals(
             "default",
-            resource.getPathByEnvironment(env("ru", "US", LIGHT, XHDPI))
+            resource.getResourceItemByEnvironment(env("ru", "US", LIGHT, XHDPI)).path
         )
         assertEquals(
             "dark",
-            resource.getPathByEnvironment(env("ru", "US", DARK, XHDPI))
+            resource.getResourceItemByEnvironment(env("ru", "US", DARK, XHDPI)).path
         )
 
         val resourceWithNoDefault = DrawableResource(
             id = "ImageResource:test2",
             items = setOf(
-                ResourceItem(setOf(LanguageQualifier("en")), "en"),
-                ResourceItem(setOf(LanguageQualifier("fr"), LIGHT), "fr-light")
+                ResourceItem(setOf(LanguageQualifier("en")), "en", -1, -1),
+                ResourceItem(setOf(LanguageQualifier("fr"), LIGHT), "fr-light", -1, -1)
             )
         )
         assertFailsWith<IllegalStateException> {
-            resourceWithNoDefault.getPathByEnvironment(env("ru", "US", DARK, XHDPI))
+            resourceWithNoDefault.getResourceItemByEnvironment(env("ru", "US", DARK, XHDPI))
         }.message.let { msg ->
             assertEquals("Resource with ID='ImageResource:test2' not found", msg)
         }
@@ -89,22 +89,14 @@ class ResourceTest {
         val resourceWithFewFiles = DrawableResource(
             id = "ImageResource:test3",
             items = setOf(
-                ResourceItem(setOf(LanguageQualifier("en")), "en1"),
-                ResourceItem(setOf(LanguageQualifier("en")), "en2")
+                ResourceItem(setOf(LanguageQualifier("en")), "en1", -1, -1),
+                ResourceItem(setOf(LanguageQualifier("en")), "en2", -1, -1)
             )
         )
         assertFailsWith<IllegalStateException> {
-            resourceWithFewFiles.getPathByEnvironment(env("en", "US", DARK, XHDPI))
+            resourceWithFewFiles.getResourceItemByEnvironment(env("en", "US", DARK, XHDPI))
         }.message.let { msg ->
             assertEquals("Resource with ID='ImageResource:test3' has more than one file: en1, en2", msg)
         }
     }
-
-    @Test
-    fun testEscapedSymbols() {
-        assertEquals(
-            "abc \n \\n \t \\t \u1234 \ua45f \\u1234 \\ \\u355g",
-            handleSpecialCharacters("""abc \n \\n \t \\t \u1234 \ua45f \\u1234 \\ \u355g""")
-        )
-    }
 }

components/resources/library/src/commonTest/kotlin/org/jetbrains/compose/resources/TestResourceReader.kt

@@ -8,4 +8,9 @@ internal class TestResourceReader : ResourceReader {
         readPathsList.add(path)
         return DefaultResourceReader.read(path)
     }
+
+    override suspend fun readPart(path: String, offset: Long, size: Long): ByteArray {
+        readPathsList.add("$path/$offset-$size")
+        return DefaultResourceReader.readPart(path, offset, size)
+    }
 }

components/resources/library/src/commonTest/kotlin/org/jetbrains/compose/resources/TestUtils.kt

@@ -4,18 +4,38 @@ import org.jetbrains.compose.resources.plural.PluralCategory
 import org.jetbrains.compose.resources.plural.PluralRule
 import org.jetbrains.compose.resources.plural.PluralRuleList
 
-@OptIn(InternalResourceApi::class, ExperimentalResourceApi::class)
+private val cvrMap: Map<String, ResourceItem> = mapOf(
+    "accentuated_characters" to ResourceItem(setOf(), "strings.cvr", 259, 54),
+    "app_name" to ResourceItem(setOf(), "strings.cvr", 314, 44),
+    "hello" to ResourceItem(setOf(), "strings.cvr", 359, 37),
+    "str_template" to ResourceItem(setOf(), "strings.cvr", 397, 76),
+
+    "another_plurals" to ResourceItem(setOf(), "strings.cvr", 10, 71),
+    "messages" to ResourceItem(setOf(), "strings.cvr", 82, 88),
+    "plurals" to ResourceItem(setOf(), "strings.cvr", 171, 39),
+
+    "str_arr" to ResourceItem(setOf(), "strings.cvr", 211, 47),
+)
+
+@OptIn(ExperimentalResourceApi::class)
 internal fun TestStringResource(key: String) = StringResource(
     "STRING:$key",
     key,
-    setOf(ResourceItem(emptySet(), "strings.xml"))
+    setOf(cvrMap[key] ?: error("String ID=`$key` is not found!"))
+)
+
+@OptIn(ExperimentalResourceApi::class)
+internal fun TestStringArrayResource(key: String) = StringArrayResource(
+    "STRING:$key",
+    key,
+    setOf(cvrMap[key] ?: error("String ID=`$key` is not found!"))
 )
 
-@OptIn(InternalResourceApi::class, ExperimentalResourceApi::class)
+@OptIn(ExperimentalResourceApi::class)
 internal fun TestPluralStringResource(key: String) = PluralStringResource(
     "PLURALS:$key",
     key,
-    setOf(ResourceItem(emptySet(), "strings.xml"))
+    setOf(cvrMap[key] ?: error("String ID=`$key` is not found!"))
 )
 
 internal fun parsePluralSamples(samples: String): List<Int> {

components/resources/library/src/commonTest/resources/strings.cvr

@@ -0,0 +1,9 @@
+version:0
+plurals|another_plurals|ONE:YW5vdGhlciBvbmU=,OTHER:YW5vdGhlciBvdGhlcg==
+plurals|messages|ONE:JTEkZCBtZXNzYWdlIGZvciAlMiRz,OTHER:JTEkZCBtZXNzYWdlcyBmb3IgJTIkcw==
+plurals|plurals|ONE:b25l,OTHER:b3RoZXI=
+string-array|str_arr|aXRlbSAx,aXRlbSAy,aXRlbSAz
+string|accentuated_characters|Q3LDqWVyIHVuZSB0YWJsZQ==
+string|app_name|Q29tcG9zZSBSZXNvdXJjZXMgQXBw
+string|hello|8J+YiiBIZWxsbyB3b3JsZCE=
+string|str_template|SGVsbG8sICUxJHMhIFlvdSBoYXZlICUyJGQgbmV3IG1lc3NhZ2VzLg==

components/resources/library/src/commonTest/resources/strings.xml

@@ -1,23 +0,0 @@
-<resources>
-    <string name="app_name">Compose Resources App</string>
-    <string name="hello">😊 Hello world!</string>
-    <string name="accentuated_characters">Créer une table</string>
-    <string name="str_template">Hello, %1$s! You have %2$d new messages.</string>
-    <string-array name="str_arr">
-        <item>item 1</item>
-        <item>item 2</item>
-        <item>item 3</item>
-    </string-array>
-    <plurals name="plurals">
-        <item quantity="one">one</item>
-        <item quantity="other">other</item>
-    </plurals>
-    <plurals name="another_plurals">
-        <item quantity="one">another one</item>
-        <item quantity="other">another other</item>
-    </plurals>
-    <plurals name="messages">
-        <item quantity="one">%1$d message for %2$s</item>
-        <item quantity="other">%1$d messages for %2$s</item>
-    </plurals>
-</resources>

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources/PrepareComposeResources.kt

@@ -202,34 +202,34 @@ internal abstract class XmlValuesConverterTask : DefaultTask() {
 
     private fun String.asBase64() =
         Base64.getEncoder().encode(this.encodeToByteArray()).decodeToString()
+}
 
-    //https://developer.android.com/guide/topics/resources/string-resource#escaping_quotes
-    /**
-     * Replaces
-     *
-     * '\n' -> new line
-     *
-     * '\t' -> tab
-     *
-     * '\uXXXX' -> unicode symbol
-     *
-     * '\\' -> '\'
-     *
-     * @param string The input string to handle.
-     * @return The string with special characters replaced according to the logic.
-     */
-    private fun handleSpecialCharacters(string: String): String {
-        val unicodeNewLineTabRegex = Regex("""\\u[a-fA-F\d]{4}|\\n|\\t""")
-        val doubleSlashRegex = Regex("""\\\\""")
-        val doubleSlashIndexes = doubleSlashRegex.findAll(string).map { it.range.first }
-        val handledString = unicodeNewLineTabRegex.replace(string) { matchResult ->
-            if (doubleSlashIndexes.contains(matchResult.range.first - 1)) matchResult.value
-            else when (matchResult.value) {
-                "\\n" -> "\n"
-                "\\t" -> "\t"
-                else -> matchResult.value.substring(2).toInt(16).toChar().toString()
-            }
-        }.replace("""\\""", """\""")
-        return handledString
-    }
+//https://developer.android.com/guide/topics/resources/string-resource#escaping_quotes
+/**
+ * Replaces
+ *
+ * '\n' -> new line
+ *
+ * '\t' -> tab
+ *
+ * '\uXXXX' -> unicode symbol
+ *
+ * '\\' -> '\'
+ *
+ * @param string The input string to handle.
+ * @return The string with special characters replaced according to the logic.
+ */
+internal fun handleSpecialCharacters(string: String): String {
+    val unicodeNewLineTabRegex = Regex("""\\u[a-fA-F\d]{4}|\\n|\\t""")
+    val doubleSlashRegex = Regex("""\\\\""")
+    val doubleSlashIndexes = doubleSlashRegex.findAll(string).map { it.range.first }
+    val handledString = unicodeNewLineTabRegex.replace(string) { matchResult ->
+        if (doubleSlashIndexes.contains(matchResult.range.first - 1)) matchResult.value
+        else when (matchResult.value) {
+            "\\n" -> "\n"
+            "\\t" -> "\t"
+            else -> matchResult.value.substring(2).toInt(16).toChar().toString()
+        }
+    }.replace("""\\""", """\""")
+    return handledString
 }

gradle-plugins/compose/src/test/kotlin/org/jetbrains/compose/test/tests/unit/TestEscapedResourceSymbols.kt

@@ -0,0 +1,16 @@
+package org.jetbrains.compose.test.tests.unit
+
+import org.jetbrains.compose.resources.handleSpecialCharacters
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class TestEscapedResourceSymbols {
+
+    @Test
+    fun testEscapedSymbols() {
+        assertEquals(
+            "abc \n \\n \t \\t \u1234 \ua45f \\u1234 \\ \\u355g",
+            handleSpecialCharacters("""abc \n \\n \t \\t \u1234 \ua45f \\u1234 \\ \u355g""")
+        )
+    }
+}