@hot-updater/react-native 1.0.0-rc.17 → 1.0.0-rc.21

package/android/src/test/java/com/hotupdater/KeyValueStorageServiceTest.kt

@@ -1,106 +0,0 @@
-package com.hotupdater
-
-import org.json.JSONObject
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Rule
-import org.junit.Test
-import org.junit.rules.TemporaryFolder
-import java.io.File
-
-class KeyValueStorageServiceTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `sets replaces and removes values`() {
-        val storage = KeyValueStorageService(storageFile())
-        assertNull(storage.getItem("plugins/insights/queue"))
-
-        storage.setItem("plugins/insights/queue", "[1]")
-        storage.setItem("plugins/insights/day", "2026-09-30")
-        storage.setItem("plugins/insights/queue", "[1,2]")
-        storage.setItem("plugins/other/empty", "")
-        assertEquals("[1,2]", storage.getItem("plugins/insights/queue"))
-        assertEquals("", storage.getItem("plugins/other/empty"))
-
-        storage.setItem("plugins/insights/queue", null)
-        storage.setItem("plugins/never-set", null)
-        assertNull(storage.getItem("plugins/insights/queue"))
-        assertEquals("2026-09-30", storage.getItem("plugins/insights/day"))
-    }
-
-    @Test
-    fun `values persist across instances`() {
-        val file = storageFile()
-        KeyValueStorageService(file).apply {
-            setItem("plugins/insights/queue", "[{\"id\":\"é\",\"note\":\"line\\nbreak\"}]")
-            setItem("plugins/insights/day", "2026-09-30")
-            setItem("plugins/insights/day", null)
-        }
-
-        val reloaded = KeyValueStorageService(file)
-
-        assertEquals("[{\"id\":\"é\",\"note\":\"line\\nbreak\"}]", reloaded.getItem("plugins/insights/queue"))
-        assertNull(reloaded.getItem("plugins/insights/day"))
-    }
-
-    @Test
-    fun `a corrupt file reads as empty and the next set replaces it`() {
-        val file = storageFile().apply { writeText("{\"plugins/a\":") }
-        val storage = KeyValueStorageService(file)
-
-        assertNull(storage.getItem("plugins/a"))
-        storage.setItem("plugins/b", "value")
-
-        assertEquals(mapOf("plugins/b" to "value"), readStored(file))
-    }
-
-    @Test
-    fun `values that are not strings read as missing`() {
-        val file = storageFile().apply { writeText("{\"plugins/a\":1,\"plugins/b\":\"kept\",\"plugins/c\":null}") }
-        val storage = KeyValueStorageService(file)
-
-        assertNull(storage.getItem("plugins/a"))
-        assertEquals("kept", storage.getItem("plugins/b"))
-        assertNull(storage.getItem("plugins/c"))
-    }
-
-    @Test
-    fun `concurrent sets are all persisted`() {
-        val file = storageFile()
-        val storage = KeyValueStorageService(file)
-
-        (0 until 4)
-            .map { worker ->
-                Thread {
-                    repeat(25) { index -> storage.setItem("plugins/worker-$worker/$index", "$worker:$index") }
-                }.apply { start() }
-            }.forEach(Thread::join)
-
-        val stored = readStored(file)
-        assertEquals(100, stored.size)
-        (0 until 4).forEach { worker ->
-            repeat(25) { index -> assertEquals("$worker:$index", stored["plugins/worker-$worker/$index"]) }
-        }
-    }
-
-    @Test
-    fun `is stored under noBackupFilesDir`() {
-        val noBackupDirectory = temporaryFolder.newFolder("no_backup")
-
-        KeyValueStorageService.create(NoBackupContext(noBackupDirectory)).setItem("plugins/insights/queue", "[]")
-
-        assertEquals(
-            mapOf("plugins/insights/queue" to "[]"),
-            readStored(File(noBackupDirectory, "hot-updater/storage.json")),
-        )
-    }
-
-    private fun storageFile(): File = File(temporaryFolder.newFolder(), "hot-updater/storage.json").apply { parentFile?.mkdirs() }
-
-    private fun readStored(file: File): Map<String, String> {
-        val json = JSONObject(file.readText())
-        return json.keys().asSequence().associateWith { json.getString(it) }
-    }
-}

package/android/src/test/java/com/hotupdater/NativeConfigUtilsTest.kt

@@ -1,20 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Test
-
-class NativeConfigUtilsTest {
-    @Test
-    fun `coerces typed manifest metadata to strings`() {
-        assertEquals("123", NativeConfigUtils.coerceManifestMetaDataString(123))
-        assertEquals("true", NativeConfigUtils.coerceManifestMetaDataString(true))
-        assertEquals("-16711936", NativeConfigUtils.coerceManifestMetaDataString(-16711936))
-    }
-
-    @Test
-    fun `ignores missing and empty manifest metadata`() {
-        assertNull(NativeConfigUtils.coerceManifestMetaDataString(null))
-        assertNull(NativeConfigUtils.coerceManifestMetaDataString(""))
-    }
-}

package/android/src/test/java/com/hotupdater/NoBackupContext.kt

@@ -1,11 +0,0 @@
-package com.hotupdater
-
-import android.content.ContextWrapper
-import java.io.File
-
-/** A context whose `noBackupFilesDir` is a test directory. */
-internal class NoBackupContext(
-    private val noBackupDirectory: File,
-) : ContextWrapper(null) {
-    override fun getNoBackupFilesDir(): File = noBackupDirectory
-}

package/android/src/test/java/com/hotupdater/OkHttpDownloadServiceTest.kt

@@ -1,397 +0,0 @@
-package com.hotupdater
-
-import kotlinx.coroutines.runBlocking
-import okhttp3.ResponseBody.Companion.toResponseBody
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Rule
-import org.junit.Test
-import org.junit.rules.TemporaryFolder
-import java.io.File
-import java.net.InetAddress
-import java.net.ServerSocket
-import java.net.Socket
-import java.net.URL
-import kotlin.concurrent.thread
-
-class OkHttpDownloadServiceTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `downloadFile succeeds when content length is unknown`() =
-        runBlocking {
-            val payload = "bundle-content-without-content-length".repeat(512).toByteArray()
-            val server = ChunkedResponseServer(payload)
-
-            try {
-                val destinationDir = temporaryFolder.newFolder("downloads")
-                val destination = File(destinationDir, "bundle.android.bundle")
-                var reportedSize: Long? = null
-
-                val result =
-                    OkHttpDownloadService().downloadFile(
-                        fileUrl = URL("http://127.0.0.1:${server.port}/bundle"),
-                        destination = destination,
-                        fileSizeCallback = { size -> reportedSize = size },
-                        progressCallback = {},
-                    )
-
-                assertTrue(result is DownloadResult.Success)
-                assertEquals(payload.size.toLong(), destination.length())
-                assertArrayEquals(payload, destination.readBytes())
-                assertNull(reportedSize)
-            } finally {
-                server.close()
-            }
-        }
-
-    @Test
-    fun `downloadFile reports a non-2xx response with its status and origin error code`() =
-        runBlocking {
-            val errorBody =
-                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
-                    "<Error><Code>NoSuchKey</Code><Message>The specified key does not exist.</Message>" +
-                    "<Key>bundles/secret/manifest.json</Key></Error>"
-            val server = ChunkedResponseServer(errorBody.toByteArray(), statusLine = "404 Not Found")
-
-            try {
-                val destination = File(temporaryFolder.newFolder("http-error"), "manifest.json")
-
-                val result =
-                    OkHttpDownloadService().downloadFile(
-                        fileUrl = URL("http://127.0.0.1:${server.port}/manifest.json"),
-                        destination = destination,
-                        progressCallback = {},
-                    )
-
-                val error = (result as DownloadResult.Error).exception
-                assertTrue("Expected HttpStatusException, got $error", error is HttpStatusException)
-                assertEquals(404, (error as HttpStatusException).statusCode)
-                assertEquals("NoSuchKey", error.originCode)
-                assertEquals("HTTP error 404: Not Found", error.message)
-                assertFalse(destination.exists())
-            } finally {
-                server.close()
-            }
-        }
-
-    @Test
-    fun `origin error codes come only from an XML Error Code of safe characters`() {
-        val cases =
-            mapOf(
-                "<Error><Code>AccessDenied</Code><Message>Access Denied</Message></Error>" to "AccessDenied",
-                "<?xml version='1.0' encoding='UTF-8'?><Error><Code>SignatureDoesNotMatch</Code></Error>" to "SignatureDoesNotMatch",
-                "<Error xmlns=\"urn:storage\">\n  <Message>first</Message>\n  <Code> ExpiredToken </Code>\n</Error>" to "ExpiredToken",
-                "<Error><Code>Rate.Limit_Exceeded-2</Code></Error>" to "Rate.Limit_Exceeded-2",
-                "<Error><Code>${"A".repeat(64)}</Code></Error>" to "A".repeat(64),
-                "<Error><Code>${"A".repeat(65)}</Code></Error>" to null,
-                "<Error><Code>Access Denied</Code></Error>" to null,
-                "<Error><Code>bundles/secret.json</Code></Error>" to null,
-                "<Error><Code></Code></Error>" to null,
-                "<Error><Message>No code</Message></Error><Code>Outside</Code>" to null,
-                "<Response><Code>NotAnError</Code></Response>" to null,
-                "Not Found" to null,
-            )
-
-        cases.forEach { (body, expected) -> assertEquals(body, expected, parseOriginErrorCode(body)) }
-    }
-
-    @Test
-    fun `origin error codes are read from the first 4 KB of the body only`() {
-        val limit = MAX_ORIGIN_ERROR_BODY_BYTES.toInt()
-        val code = "<Error><Code>AccessDenied</Code>"
-        val endsAtLimit = " ".repeat(limit - code.length) + code + "</Error>"
-        val closesPastLimit = " ".repeat(limit - code.length + 1) + code + "</Error>"
-
-        assertEquals("AccessDenied", readOriginErrorCode(endsAtLimit.toResponseBody()))
-        assertNull(readOriginErrorCode(closesPastLimit.toResponseBody()))
-        assertNull(readOriginErrorCode(null))
-    }
-
-    @Test
-    fun `downloadFile reports a destination it cannot write as a local storage failure`() =
-        runBlocking {
-            val server = ChunkedResponseServer("bundle-content".toByteArray())
-
-            try {
-                val notADirectory = temporaryFolder.newFile("not-a-directory")
-
-                val result =
-                    OkHttpDownloadService().downloadFile(
-                        fileUrl = URL("http://127.0.0.1:${server.port}/bundle"),
-                        destination = File(notADirectory, "index.android.bundle"),
-                        progressCallback = {},
-                    )
-
-                val error = (result as DownloadResult.Error).exception
-                assertTrue("Expected LocalStorageException, got $error", error is LocalStorageException)
-            } finally {
-                server.close()
-            }
-        }
-
-    @Test
-    fun `downloadFile tries a transient failure again and succeeds on the next attempt`() =
-        runBlocking {
-            val payload = "bundle-after-retry".toByteArray()
-            val server =
-                SequencedResponseServer(
-                    listOf(
-                        "503 Service Unavailable" to "busy".toByteArray(),
-                        "200 OK" to payload,
-                    ),
-                )
-
-            try {
-                val destination = File(temporaryFolder.newFolder("retry"), "index.android.bundle")
-
-                val result =
-                    OkHttpDownloadService(initialRetryDelayMs = 1).downloadFile(
-                        fileUrl = URL("http://127.0.0.1:${server.port}/bundle"),
-                        destination = destination,
-                        progressCallback = {},
-                    )
-
-                assertTrue("Expected success, got $result", result is DownloadResult.Success)
-                assertArrayEquals(payload, destination.readBytes())
-                assertEquals(2, server.requestCount)
-            } finally {
-                server.close()
-            }
-        }
-
-    @Test
-    fun `downloadFile tries a 404 once`() =
-        runBlocking {
-            val server =
-                SequencedResponseServer(
-                    listOf(
-                        "404 Not Found" to "missing".toByteArray(),
-                        "200 OK" to "never-sent".toByteArray(),
-                    ),
-                )
-
-            try {
-                val result =
-                    OkHttpDownloadService(initialRetryDelayMs = 1).downloadFile(
-                        fileUrl = URL("http://127.0.0.1:${server.port}/bundle"),
-                        destination = File(temporaryFolder.newFolder("not-found"), "index.android.bundle"),
-                        progressCallback = {},
-                    )
-
-                val error = (result as DownloadResult.Error).exception
-                assertEquals(404, (error as HttpStatusException).statusCode)
-                assertEquals(1, server.requestCount)
-            } finally {
-                server.close()
-            }
-        }
-
-    @Test
-    fun `downloadFile stops after three attempts and returns the last classified failure`() =
-        runBlocking {
-            val server =
-                SequencedResponseServer(
-                    listOf(
-                        "500 Internal Server Error" to "one".toByteArray(),
-                        "429 Too Many Requests" to "two".toByteArray(),
-                        "502 Bad Gateway" to "<Error><Code>SlowDown</Code></Error>".toByteArray(),
-                        "200 OK" to "never-sent".toByteArray(),
-                    ),
-                )
-
-            try {
-                val result =
-                    OkHttpDownloadService(initialRetryDelayMs = 1).downloadFile(
-                        fileUrl = URL("http://127.0.0.1:${server.port}/bundle"),
-                        destination = File(temporaryFolder.newFolder("exhausted"), "index.android.bundle"),
-                        progressCallback = {},
-                    )
-
-                val error = (result as DownloadResult.Error).exception as HttpStatusException
-                assertEquals(502, error.statusCode)
-                assertEquals("SlowDown", error.originCode)
-                assertEquals(UpdateFailure.http(502, "SlowDown"), UpdateFailure.ofDownloadError(error))
-                assertEquals(OkHttpDownloadService.MAX_ATTEMPTS, server.requestCount)
-            } finally {
-                server.close()
-            }
-        }
-
-    @Test
-    fun `downloadFileOnce does not retry`() =
-        runBlocking {
-            val server =
-                SequencedResponseServer(
-                    listOf(
-                        "503 Service Unavailable" to "busy".toByteArray(),
-                        "200 OK" to "never-sent".toByteArray(),
-                    ),
-                )
-
-            try {
-                val result =
-                    OkHttpDownloadService(initialRetryDelayMs = 1).downloadFileOnce(
-                        fileUrl = URL("http://127.0.0.1:${server.port}/bundle.tar.br"),
-                        destination = File(temporaryFolder.newFolder("once"), "bundle.tar.br"),
-                        progressCallback = {},
-                    )
-
-                assertTrue(result is DownloadResult.Error)
-                assertEquals(1, server.requestCount)
-            } finally {
-                server.close()
-            }
-        }
-
-    @Test
-    fun `only transient download failures are retryable`() {
-        val retryable =
-            listOf(
-                HttpStatusException(408, "Request Timeout"),
-                HttpStatusException(429, "Too Many Requests"),
-                HttpStatusException(500, "Internal Server Error"),
-                HttpStatusException(503, "Service Unavailable"),
-                java.net.SocketTimeoutException("timeout"),
-                java.net.UnknownHostException("updates.example.com"),
-                java.net.ConnectException("Connection refused"),
-                IncompleteDownloadException(expectedSize = 10, actualSize = 4),
-            )
-        val final =
-            listOf(
-                HttpStatusException(400, "Bad Request"),
-                HttpStatusException(403, "Forbidden", "ExpiredToken"),
-                HttpStatusException(404, "Not Found"),
-                LocalStorageException(java.io.IOException("No space left on device")),
-                javax.net.ssl.SSLHandshakeException("certificate expired"),
-                java.io.IOException("Canceled"),
-                java.net.MalformedURLException("no protocol"),
-                IllegalArgumentException("unexpected url"),
-                Exception("Response body is null"),
-            )
-
-        retryable.forEach { assertTrue("$it should be retryable", isRetryableDownloadError(it)) }
-        final.forEach { assertFalse("$it should not be retryable", isRetryableDownloadError(it)) }
-    }
-
-    /** Answers each connection with the next response, then closes. */
-    private class SequencedResponseServer(
-        private val responses: List<Pair<String, ByteArray>>,
-    ) : AutoCloseable {
-        private val serverSocket = ServerSocket(0, responses.size, InetAddress.getByName("127.0.0.1"))
-
-        @Volatile
-        var requestCount = 0
-            private set
-
-        private val worker =
-            thread(start = true, isDaemon = true) {
-                try {
-                    for ((statusLine, payload) in responses) {
-                        serverSocket.accept().use { client ->
-                            requestCount++
-                            respond(client, statusLine, payload)
-                        }
-                    }
-                } catch (_: java.net.SocketException) {
-                    // The test closed the server before every response was asked for.
-                }
-            }
-
-        val port: Int = serverSocket.localPort
-
-        private fun respond(
-            client: Socket,
-            statusLine: String,
-            payload: ByteArray,
-        ) {
-            drainRequestHeaders(client)
-            client.getOutputStream().use { output ->
-                output.write(
-                    (
-                        "HTTP/1.1 $statusLine\r\n" +
-                            "Content-Type: application/octet-stream\r\n" +
-                            "Content-Length: ${payload.size}\r\n" +
-                            "Connection: close\r\n" +
-                            "\r\n"
-                    ).toByteArray(),
-                )
-                output.write(payload)
-                output.flush()
-            }
-        }
-
-        override fun close() {
-            serverSocket.close()
-            worker.join(1_000)
-        }
-    }
-
-    private class ChunkedResponseServer(
-        private val payload: ByteArray,
-        private val statusLine: String = "200 OK",
-    ) : AutoCloseable {
-        private val serverSocket = ServerSocket(0, 1, InetAddress.getByName("127.0.0.1"))
-        private val worker =
-            thread(start = true, isDaemon = true) {
-                serverSocket.use { socket ->
-                    socket.accept().use(::respond)
-                }
-            }
-
-        val port: Int = serverSocket.localPort
-
-        private fun respond(client: Socket) {
-            drainRequestHeaders(client)
-
-            client.getOutputStream().use { output ->
-                output.write(
-                    (
-                        "HTTP/1.1 $statusLine\r\n" +
-                            "Content-Type: application/octet-stream\r\n" +
-                            "Transfer-Encoding: chunked\r\n" +
-                            "Connection: close\r\n" +
-                            "\r\n"
-                    ).toByteArray(),
-                )
-                output.write(payload.size.toString(16).toByteArray())
-                output.write("\r\n".toByteArray())
-                output.write(payload)
-                output.write("\r\n0\r\n\r\n".toByteArray())
-                output.flush()
-            }
-        }
-
-        override fun close() {
-            serverSocket.close()
-            worker.join(1_000)
-        }
-    }
-}
-
-/** Reads a request up to the blank line after its headers. */
-private fun drainRequestHeaders(client: Socket) {
-    val input = client.getInputStream()
-    var matched = 0
-    val terminator = byteArrayOf('\r'.code.toByte(), '\n'.code.toByte(), '\r'.code.toByte(), '\n'.code.toByte())
-
-    while (matched < terminator.size) {
-        val next = input.read()
-        if (next == -1) {
-            break
-        }
-
-        matched =
-            if (next.toByte() == terminator[matched]) {
-                matched + 1
-            } else if (next.toByte() == terminator[0]) {
-                1
-            } else {
-                0
-            }
-    }
-}

package/android/src/test/java/com/hotupdater/PendingCrashRecoveryTest.kt

@@ -1,44 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNull
-import org.junit.Rule
-import org.junit.Test
-import org.junit.rules.TemporaryFolder
-import java.io.File
-
-class PendingCrashRecoveryTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `a watchdog reader waits until the native crash marker is fully written`() {
-        val marker = temporaryFolder.newFile("crash-marker.json")
-        marker.writeText("{\"bundleId\":\"crashed-bundle\",\"shouldRollback\":")
-
-        assertNull(PendingCrashRecovery.loadFromFile(marker))
-
-        marker.appendText("true}\n")
-        assertEquals(
-            PendingCrashRecovery("crashed-bundle", true),
-            PendingCrashRecovery.loadFromFile(marker),
-        )
-    }
-
-    @Test
-    fun `missing or empty markers do not request a restart`() {
-        assertNull(PendingCrashRecovery.loadFromFile(File(temporaryFolder.root, "missing.json")))
-        assertNull(PendingCrashRecovery.loadFromFile(temporaryFolder.newFile("empty.json")))
-    }
-
-    @Test
-    fun `a crash after content appeared does not request rollback`() {
-        val marker = temporaryFolder.newFile("verified-crash.json")
-        marker.writeText("{\"bundleId\":\"verified-bundle\",\"shouldRollback\":false}")
-
-        val recovery = requireNotNull(PendingCrashRecovery.loadFromFile(marker))
-        assertFalse(recovery.shouldRollback)
-        assertEquals("verified-bundle", recovery.launchedBundleId)
-    }
-}

package/android/src/test/java/com/hotupdater/PreviousProcessExitTest.kt

@@ -1,57 +0,0 @@
-package com.hotupdater
-
-import com.hotupdater.PreviousProcessExit.ExitRecord
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Test
-
-class PreviousProcessExitTest {
-    @Test
-    fun `reasons are named after ApplicationExitInfo without the REASON prefix`() {
-        val names =
-            listOf(
-                "UNKNOWN",
-                "EXIT_SELF",
-                "SIGNALED",
-                "LOW_MEMORY",
-                "CRASH",
-                "CRASH_NATIVE",
-                "ANR",
-                "INITIALIZATION_FAILURE",
-                "PERMISSION_CHANGE",
-                "EXCESSIVE_RESOURCE_USAGE",
-                "USER_REQUESTED",
-                "USER_STOPPED",
-                "DEPENDENCY_DIED",
-                "OTHER",
-                "FREEZER",
-                "PACKAGE_STATE_CHANGE",
-                "PACKAGE_UPDATED",
-            )
-
-        assertEquals(names, names.indices.map(PreviousProcessExit::reasonName))
-        assertEquals("UNKNOWN", PreviousProcessExit.reasonName(99))
-        assertEquals("UNKNOWN", PreviousProcessExit.reasonName(-1))
-    }
-
-    @Test
-    fun `the most recent exit of the main process is selected`() {
-        val records =
-            listOf(
-                ExitRecord("com.example:hotupdater_restart", reason = 1, timestamp = 300),
-                ExitRecord("com.example", reason = 4, timestamp = 100),
-                ExitRecord("com.example", reason = 6, timestamp = 200),
-                ExitRecord("com.example:sync", reason = 3, timestamp = 250),
-                ExitRecord(null, reason = 5, timestamp = 400),
-            )
-
-        assertEquals(6, PreviousProcessExit.selectReason(records, "com.example"))
-        assertNull(PreviousProcessExit.selectReason(records.filter { it.processName != "com.example" }, "com.example"))
-        assertNull(PreviousProcessExit.selectReason(emptyList(), "com.example"))
-    }
-
-    @Test
-    fun `nothing is reported before HotUpdater initializes`() {
-        assertNull(PreviousProcessExit.get())
-    }
-}

package/android/src/test/java/com/hotupdater/RelativePathResolverTest.kt

@@ -1,41 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Rule
-import org.junit.Test
-import org.junit.rules.TemporaryFolder
-import java.io.File
-
-class RelativePathResolverTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `resolves a standard archive directory entry ending in a slash`() {
-        val root = temporaryFolder.root
-
-        val resolved = RelativePathResolver.resolveInside(root, "drawable-mdpi/")
-
-        assertEquals(
-            File(root, "drawable-mdpi").canonicalFile,
-            resolved?.canonicalFile,
-        )
-    }
-
-    @Test
-    fun `rejects unsafe archive directory paths ending in a slash`() {
-        val root = temporaryFolder.root
-        val unsafePaths =
-            listOf(
-                "/",
-                "../",
-                "drawable-mdpi/../",
-                "drawable-mdpi//",
-            )
-
-        unsafePaths.forEach { path ->
-            assertNull(path, RelativePathResolver.resolveInside(root, path))
-        }
-    }
-}