react-native-audio-browser 0.2.0-next.9 → 0.2.0

package/android/src/test/java/com/audiobrowser/player/StuckRecoveryPolicyTest.kt

@@ -1,40 +0,0 @@
-package com.audiobrowser.player
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class StuckRecoveryPolicyTest {
-  @Test
-  fun `first stuck event recovers`() {
-    val p = StuckRecoveryPolicy(maxRecoveries = 3)
-    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck())
-  }
-
-  @Test
-  fun `recovers up to max then gives up`() {
-    val p = StuckRecoveryPolicy(maxRecoveries = 3)
-    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 1
-    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 2
-    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 3
-    assertEquals(StuckRecoveryPolicy.Decision.GIVE_UP, p.onStuck()) // 4 -> exhausted
-  }
-
-  @Test
-  fun `give up is sticky and does not self-refill`() {
-    val p = StuckRecoveryPolicy(maxRecoveries = 3)
-    repeat(3) { p.onStuck() }
-    assertEquals(StuckRecoveryPolicy.Decision.GIVE_UP, p.onStuck()) // 4
-    assertEquals(StuckRecoveryPolicy.Decision.GIVE_UP, p.onStuck()) // still GIVE_UP, no refill
-  }
-
-  @Test
-  fun `reset refills the budget`() {
-    val p = StuckRecoveryPolicy(maxRecoveries = 3)
-    repeat(4) { p.onStuck() } // now exhausted
-    p.reset()
-    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 1
-    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 2
-    assertEquals(StuckRecoveryPolicy.Decision.RECOVER, p.onStuck()) // 3
-    assertEquals(StuckRecoveryPolicy.Decision.GIVE_UP, p.onStuck()) // 4
-  }
-}

package/android/src/test/java/com/audiobrowser/player/TransformingDataSourceTest.kt

@@ -1,193 +0,0 @@
-package com.audiobrowser.player
-
-import android.net.Uri
-import androidx.core.net.toUri
-import androidx.media3.common.C
-import androidx.media3.datasource.DataSource
-import androidx.media3.datasource.DataSpec
-import androidx.media3.datasource.TransferListener
-import com.margelo.nitro.audiobrowser.MediaRequestConfig
-import java.io.IOException
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-
-@RunWith(RobolectricTestRunner::class)
-class TransformingDataSourceTest {
-
-  // Records the URL each upstream DataSource is actually opened with.
-  private val openedUrls = mutableListOf<String>()
-
-  // When set, the next upstream open() records its URL and then throws (simulating a failed load).
-  private var failNextOpen = false
-
-  private inner class RecordingDataSource(
-    private val responseHeaders: Map<String, List<String>> = emptyMap()
-  ) : DataSource {
-    override fun open(dataSpec: DataSpec): Long {
-      openedUrls.add(dataSpec.uri.toString())
-      if (failNextOpen) {
-        failNextOpen = false
-        throw IOException("simulated load failure")
-      }
-      return C.LENGTH_UNSET.toLong()
-    }
-
-    override fun read(buffer: ByteArray, offset: Int, length: Int): Int = C.RESULT_END_OF_INPUT
-
-    override fun addTransferListener(transferListener: TransferListener) {}
-
-    override fun getUri(): Uri? = null
-
-    override fun getResponseHeaders(): Map<String, List<String>> = responseHeaders
-
-    override fun close() {}
-  }
-
-  private val upstreamFactory = DataSource.Factory { RecordingDataSource() }
-
-  private fun config(baseUrl: String, path: String) =
-    MediaRequestConfig(
-      resolve = null,
-      resolveSync = null,
-      transform = null,
-      transformSync = null,
-      method = null,
-      path = path,
-      baseUrl = baseUrl,
-      headers = null,
-      query = null,
-      body = null,
-      contentType = null,
-      userAgent = null,
-    )
-
-  private fun tokenConfig(token: Int) =
-    MediaRequestConfig(
-      resolve = null,
-      resolveSync = null,
-      transform = null,
-      transformSync = null,
-      method = null,
-      path = "/s.mp3",
-      baseUrl = "https://cdn.example.com",
-      headers = null,
-      query = mapOf("token" to token.toString()),
-      body = null,
-      contentType = null,
-      userAgent = null,
-    )
-
-  @Test
-  fun `a failed media-url load re-resolves the url on the retry (fresh token)`() {
-    // A consumer whose transform mints a short-lived token: each resolve yields a new token. If the
-    // media-URL load fails (e.g. the token expired during a network outage), ExoPlayer's retry must
-    // re-resolve to a fresh token rather than replay the stale cached URL.
-    var resolves = 0
-    val factory = TransformingDataSource.Factory(upstreamFactory) { tokenConfig(++resolves) }
-    val spec = DataSpec("/listen/abc/channel.mp3".toUri())
-
-    // First open records token=1, then fails (simulating an expired URL).
-    failNextOpen = true
-    try {
-      factory.createDataSource().open(spec)
-    } catch (_: IOException) {}
-    // The retry re-opens the same media URL — it must re-resolve to a fresh token.
-    factory.createDataSource().open(spec)
-    // A further re-open without a failure reuses token=2 (the flag is single-shot).
-    factory.createDataSource().open(spec)
-
-    assertEquals(3, openedUrls.size)
-    assertTrue("first open uses token=1, got ${openedUrls[0]}", openedUrls[0].contains("token=1"))
-    assertTrue(
-      "retry re-resolves to token=2, got ${openedUrls[1]}",
-      openedUrls[1].contains("token=2"),
-    )
-    assertTrue(
-      "subsequent open reuses token=2, got ${openedUrls[2]}",
-      openedUrls[2].contains("token=2"),
-    )
-  }
-
-  @Test
-  fun `a failed segment load does not trigger a media re-resolve`() {
-    // A segment/key failure (a different, already-absolute URL) must not refresh the media URL: the
-    // media URL is fine, only a segment hiccuped.
-    var resolves = 0
-    val factory = TransformingDataSource.Factory(upstreamFactory) { tokenConfig(++resolves) }
-
-    val mediaUrl = "/listen/abc/playlist.m3u8".toUri()
-    factory.createDataSource().open(DataSpec(mediaUrl)) // media -> token=1
-    failNextOpen = true
-    try {
-      factory.createDataSource().open(DataSpec("https://cdn.example.com/seg-1.ts".toUri()))
-    } catch (_: IOException) {}
-    // Re-open the media URL: it must still reuse token=1 (the segment failure left it valid).
-    factory.createDataSource().open(DataSpec(mediaUrl))
-
-    assertTrue(
-      "media url stays token=1, got ${openedUrls.last()}",
-      openedUrls.last().contains("token=1"),
-    )
-  }
-
-  @Test
-  fun `re-open of the media url reuses the resolved url, not the relative original`() {
-    // radio.garden's MediaItem URI is a relative path; the transform resolves it to an absolute
-    // URL.
-    val relative = "/listen/abc/channel.mp3"
-    val factory =
-      TransformingDataSource.Factory(upstreamFactory) {
-        config("https://cdn.example.com", "/s.mp3")
-      }
-    val spec = DataSpec(relative.toUri())
-
-    // First open resolves + caches; a re-open (e.g. a retry after a network drop) opens again.
-    factory.createDataSource().open(spec)
-    factory.createDataSource().open(spec)
-
-    assertEquals(2, openedUrls.size)
-    // The regression: the re-open must NOT fall back to the schemeless relative path (which would
-    // route to FileDataSource -> FileNotFoundException). Both opens hit the resolved absolute URL.
-    assertTrue(
-      "expected absolute urls, got $openedUrls",
-      openedUrls.all { it.startsWith("https://") },
-    )
-    assertEquals(openedUrls[0], openedUrls[1])
-  }
-
-  @Test
-  fun `response headers are forwarded from the upstream source`() {
-    // ICY (Shoutcast) song metadata only works if ExoPlayer's ProgressiveMediaPeriod can read the
-    // `icy-metaint` response header back through the data-source chain. A transparent wrapper that
-    // swallows getResponseHeaders() (returning the DataSource default empty map) silently disables
-    // ICY metadata — playback still works, but onMetadata never fires.
-    val icyHeaders = mapOf("icy-metaint" to listOf("16000"), "icy-name" to listOf("Example FM"))
-    val factory =
-      TransformingDataSource.Factory({ RecordingDataSource(icyHeaders) }) {
-        config("https://cdn.example.com", "/s.mp3")
-      }
-    val source = factory.createDataSource()
-    source.open(DataSpec("/listen/abc/channel.mp3".toUri()))
-
-    assertEquals(icyHeaders, source.responseHeaders)
-  }
-
-  @Test
-  fun `absolute segment urls pass through unchanged after the media url is resolved`() {
-    val factory =
-      TransformingDataSource.Factory(upstreamFactory) {
-        config("https://cdn.example.com", "/playlist.m3u8")
-      }
-
-    // Resolve the (relative) media/playlist URL first…
-    factory.createDataSource().open(DataSpec("/listen/abc/playlist.m3u8".toUri()))
-    // …then an already-absolute segment URL must pass through untouched (only headers are reused).
-    val segment = "https://cdn.example.com/segment-1.ts"
-    factory.createDataSource().open(DataSpec(segment.toUri()))
-
-    assertEquals(segment, openedUrls.last())
-  }
-}

package/android/src/test/java/com/audiobrowser/tls/AiaCertChaserTest.kt

@@ -1,107 +0,0 @@
-package com.audiobrowser.tls
-
-import java.security.cert.CertPathValidator
-import java.security.cert.CertPathValidatorException
-import java.security.cert.CertificateFactory
-import java.security.cert.PKIXParameters
-import java.security.cert.TrustAnchor
-import java.security.cert.X509Certificate
-import java.util.Date
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertThrows
-import org.junit.Test
-
-class AiaCertChaserTest {
-
-  @Test
-  fun `extracts CA Issuers URL from real leaf certificate AIA extension`() {
-    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
-
-    val urls = AiaCertChaser.extractCaIssuerUrls(leaf)
-
-    assertEquals(listOf("http://r13.i.lencr.org/"), urls)
-  }
-
-  @Test
-  fun `completeChain appends fetched intermediate when server sends leaf only`() {
-    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
-    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
-    // Fetcher knows only the R13 URL (the leaf's AIA pointer); empty for the root URL.
-    val fetch = { url: String ->
-      if (url == "http://r13.i.lencr.org/") listOf(r13) else emptyList()
-    }
-
-    val completed = AiaCertChaser.completeChain(listOf(leaf), fetch = fetch)
-
-    assertEquals(listOf(leaf, r13), completed)
-  }
-
-  @Test
-  fun `completeChain selects the real issuer from a multi-certificate response`() {
-    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
-    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
-    val unrelated = CertFixtures.cert("isrg-root-x1.pem") // not the leaf's issuer
-
-    // A PKCS#7-style bundle where the genuine issuer is not first must still be selected.
-    val completed =
-      AiaCertChaser.completeChain(listOf(leaf)) {
-        if (it == "http://r13.i.lencr.org/") listOf(unrelated, r13) else emptyList()
-      }
-
-    assertEquals(listOf(leaf, r13), completed)
-  }
-
-  @Test
-  fun `completeChain leaves a self-signed root untouched without fetching`() {
-    val root = CertFixtures.cert("isrg-root-x1.pem")
-    var fetches = 0
-
-    val completed =
-      AiaCertChaser.completeChain(listOf(root)) {
-        fetches++
-        emptyList()
-      }
-
-    assertEquals(listOf(root), completed)
-    assertEquals(0, fetches)
-  }
-
-  @Test
-  fun `completeChain stops when the issuer cannot be fetched`() {
-    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
-
-    val completed = AiaCertChaser.completeChain(listOf(leaf)) { emptyList() }
-
-    assertEquals(listOf(leaf), completed)
-  }
-
-  @Test
-  fun `AIA-completed chain forms a valid PKIX path to the trusted root`() {
-    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
-    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
-    val root = CertFixtures.cert("isrg-root-x1.pem")
-    // Validate as of just after issuance so the fixtures never rot when the leaf expires.
-    val date = Date(leaf.notBefore.time + 86_400_000L)
-
-    // Reproduces the Android bug: the server-sent leaf alone has no path to the trusted root.
-    assertThrows(CertPathValidatorException::class.java) { validatePath(listOf(leaf), root, date) }
-
-    // After AIA chasing splices in R13, the chain validates to the trusted root.
-    val completed =
-      AiaCertChaser.completeChain(listOf(leaf)) {
-        if (it == "http://r13.i.lencr.org/") listOf(r13) else emptyList()
-      }
-    validatePath(completed, root, date) // must not throw
-  }
-
-  /** Validates [chain] (leaf-first, excluding the anchor) against [anchor] as of [date]. */
-  private fun validatePath(chain: List<X509Certificate>, anchor: X509Certificate, date: Date) {
-    val path = CertificateFactory.getInstance("X.509").generateCertPath(chain)
-    val params =
-      PKIXParameters(setOf(TrustAnchor(anchor, null))).apply {
-        isRevocationEnabled = false
-        this.date = date
-      }
-    CertPathValidator.getInstance("PKIX").validate(path, params)
-  }
-}

package/android/src/test/java/com/audiobrowser/tls/AiaChasingTrustManagerTest.kt

@@ -1,73 +0,0 @@
-package com.audiobrowser.tls
-
-import java.security.cert.CertificateException
-import java.security.cert.X509Certificate
-import javax.net.ssl.X509TrustManager
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertThrows
-import org.junit.Test
-
-class AiaChasingTrustManagerTest {
-
-  /** Records every chain it is asked to validate; trusts only chains of [trustsChainOfSize]. */
-  private class FakeDelegate(private val trustsChainOfSize: Int) : X509TrustManager {
-    val checkedChainSizes = mutableListOf<Int>()
-
-    override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {
-      checkedChainSizes.add(chain.size)
-      if (chain.size != trustsChainOfSize) {
-        throw CertificateException("Trust anchor for certification path not found.")
-      }
-    }
-
-    override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) = Unit
-
-    override fun getAcceptedIssuers(): Array<X509Certificate> = emptyArray()
-  }
-
-  @Test
-  fun `re-validates the AIA-completed chain when the delegate rejects the leaf-only chain`() {
-    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
-    val r13 = CertFixtures.cert("letsencrypt-r13.pem")
-    val delegate = FakeDelegate(trustsChainOfSize = 2)
-    val tm =
-      AiaChasingTrustManager(delegate) {
-        if (it == "http://r13.i.lencr.org/") listOf(r13) else emptyList()
-      }
-
-    // Must not throw: the leaf-only chain is rejected, AIA fills in R13, the [leaf, R13] chain
-    // passes.
-    tm.checkServerTrusted(arrayOf(leaf), "RSA")
-
-    assertEquals(listOf(1, 2), delegate.checkedChainSizes)
-  }
-
-  @Test
-  fun `rethrows the original failure when no intermediate can be fetched`() {
-    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
-    val delegate = FakeDelegate(trustsChainOfSize = 2)
-    val tm = AiaChasingTrustManager(delegate) { emptyList() }
-
-    assertThrows(CertificateException::class.java) { tm.checkServerTrusted(arrayOf(leaf), "RSA") }
-
-    // Only the original short chain was checked; no pointless re-validation of an unchanged chain.
-    assertEquals(listOf(1), delegate.checkedChainSizes)
-  }
-
-  @Test
-  fun `does not fetch when the delegate already trusts the presented chain`() {
-    val leaf = CertFixtures.cert("stationplaylist-leaf.pem")
-    val delegate = FakeDelegate(trustsChainOfSize = 1)
-    var fetches = 0
-    val tm =
-      AiaChasingTrustManager(delegate) {
-        fetches++
-        emptyList()
-      }
-
-    tm.checkServerTrusted(arrayOf(leaf), "RSA")
-
-    assertEquals(0, fetches)
-    assertEquals(listOf(1), delegate.checkedChainSizes)
-  }
-}

package/android/src/test/java/com/audiobrowser/tls/CachingCertificateFetcherTest.kt

@@ -1,75 +0,0 @@
-package com.audiobrowser.tls
-
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-class CachingCertificateFetcherTest {
-
-  @Test
-  fun `parses a DER-encoded certificate as served by the CA`() {
-    val certs =
-      CachingCertificateFetcher.parseCertificates(CertFixtures.bytes("letsencrypt-r13.der"))
-
-    assertEquals(1, certs.size)
-    assertEquals("CN=R13,O=Let's Encrypt,C=US", certs.first().subjectX500Principal.name)
-  }
-
-  @Test
-  fun `returns empty for bytes that are not a certificate`() {
-    assertTrue(
-      CachingCertificateFetcher.parseCertificates("not a certificate".toByteArray()).isEmpty()
-    )
-  }
-
-  // -- raw HTTP/1.0 response parsing (the http AIA fetch reads to EOF, then parses) --
-
-  @Test
-  fun `extracts status and body from a content-length response`() {
-    val body = byteArrayOf(0xDE.toByte(), 0xAD.toByte(), 0xBE.toByte(), 0xEF.toByte())
-    val raw =
-      "HTTP/1.1 200 OK\r\nContent-Type: application/pkix-cert\r\nContent-Length: 4\r\n\r\n"
-        .toByteArray(Charsets.ISO_8859_1) + body
-
-    val response = CachingCertificateFetcher.parseHttpResponse(raw)!!
-
-    assertEquals(200, response.status)
-    assertNull(response.location)
-    assertArrayEquals(body, response.body)
-  }
-
-  @Test
-  fun `decodes a chunked body`() {
-    // "DEAD" + "BEEF" split across two chunks, terminated by a zero-length chunk.
-    val raw =
-      ("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" +
-          "4\r\nDEAD\r\n4\r\nBEEF\r\n0\r\n\r\n")
-        .toByteArray(Charsets.ISO_8859_1)
-
-    val response = CachingCertificateFetcher.parseHttpResponse(raw)!!
-
-    assertEquals(200, response.status)
-    assertArrayEquals("DEADBEEF".toByteArray(Charsets.ISO_8859_1), response.body)
-  }
-
-  @Test
-  fun `surfaces the redirect location for a 3xx response`() {
-    val raw =
-      "HTTP/1.1 301 Moved Permanently\r\nLocation: https://ca.example/issuer.crt\r\n\r\n"
-        .toByteArray(Charsets.ISO_8859_1)
-
-    val response = CachingCertificateFetcher.parseHttpResponse(raw)!!
-
-    assertEquals(301, response.status)
-    assertEquals("https://ca.example/issuer.crt", response.location)
-  }
-
-  @Test
-  fun `returns null when the bytes are not an HTTP response`() {
-    assertNull(
-      CachingCertificateFetcher.parseHttpResponse("garbage without a header break".toByteArray())
-    )
-  }
-}

package/android/src/test/java/com/audiobrowser/tls/CertFixtures.kt

@@ -1,18 +0,0 @@
-package com.audiobrowser.tls
-
-import java.security.cert.CertificateFactory
-import java.security.cert.X509Certificate
-
-/** Loads certificate fixtures from `src/test/resources/certs`. */
-object CertFixtures {
-  fun bytes(resource: String): ByteArray =
-    checkNotNull(CertFixtures::class.java.getResourceAsStream("/certs/$resource")) {
-        "Missing test fixture: /certs/$resource"
-      }
-      .use { it.readBytes() }
-
-  fun cert(resource: String): X509Certificate =
-    bytes(resource).inputStream().use {
-      CertificateFactory.getInstance("X.509").generateCertificate(it) as X509Certificate
-    }
-}

package/android/src/test/java/com/audiobrowser/util/ArtworkContentProviderTest.kt

@@ -1,163 +0,0 @@
-package com.audiobrowser.util
-
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.net.Uri
-import com.audiobrowser.browser.BrowseArtworkRegistry
-import com.audiobrowser.browser.ResolvedArtwork
-import java.io.File
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.Robolectric
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.RuntimeEnvironment
-
-@RunWith(RobolectricTestRunner::class)
-class ArtworkContentProviderTest {
-  private lateinit var provider: ArtworkContentProvider
-  private lateinit var registry: BrowseArtworkRegistry
-
-  @Before
-  fun setUp() {
-    provider = Robolectric.setupContentProvider(ArtworkContentProvider::class.java)
-    registry = BrowseArtworkRegistry()
-    val context = RuntimeEnvironment.getApplication()
-
-    // Delete on-disk cache so tests don't bleed into each other via cached files.
-    File(context.cacheDir, ArtworkContentProvider.ARTWORK_SUBDIR).deleteRecursively()
-
-    val fakeBitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888)
-    val loader = CoilArtworkLoader(context, FakeImageLoader(context, fakeBitmap) {})
-    CoilArtworkLoaderHolder.set(
-      ArtworkProviderDeps(loader, registry, CoroutineScope(Dispatchers.IO))
-    )
-  }
-
-  @After
-  fun tearDown() {
-    CoilArtworkLoaderHolder.get()?.let { CoilArtworkLoaderHolder.clearIf(it) }
-    // Clean up any files written during the test.
-    val context = RuntimeEnvironment.getApplication()
-    File(context.cacheDir, ArtworkContentProvider.ARTWORK_SUBDIR).deleteRecursively()
-  }
-
-  private fun uri(token: String) =
-    Uri.parse(ArtworkUris.contentUri(ArtworkUris.authorityFor("com.test"), token))
-
-  @Test
-  fun `getType is png`() {
-    assertEquals("image/png", provider.getType(uri("anything")))
-  }
-
-  @Test
-  fun `openFile returns a readable PNG for a registered http token`() {
-    val token = ArtworkUris.tokenFor("https://cdn/a.png")
-    registry.register(token, ResolvedArtwork("https://cdn/a.png", null, isSvg = false))
-    val pfd = provider.openFile(uri(token), "r")
-    assertNotNull(pfd)
-    val bytes = java.io.FileInputStream(pfd!!.fileDescriptor).readBytes()
-    assertNotNull(BitmapFactory.decodeByteArray(bytes, 0, bytes.size)) // valid image
-  }
-
-  // Prove E-mitigation: file FD has a real stat size (non-negative); a pipe FD would return -1.
-  @Test
-  fun `openFile returns a file-backed seekable FD (statSize non-negative)`() {
-    val token = ArtworkUris.tokenFor("https://cdn/seekable.png")
-    registry.register(token, ResolvedArtwork("https://cdn/seekable.png", null, isSvg = false))
-    val pfd = provider.openFile(uri(token), "r")
-    assertNotNull(pfd)
-    assertTrue("Expected statSize >= 0 for a file FD, got ${pfd!!.statSize}", pfd.statSize >= 0)
-  }
-
-  @Test
-  fun `openFile returns null for an unknown token`() {
-    assertNull(provider.openFile(uri("nope"), "r"))
-  }
-
-  @Test
-  fun `openFile returns null for a non-http registered url`() {
-    val token = ArtworkUris.tokenFor("android.resource://com.test/drawable/ic")
-    registry.register(
-      token,
-      ResolvedArtwork("android.resource://com.test/drawable/ic", null, false),
-    )
-    assertNull(provider.openFile(uri(token), "r"))
-  }
-
-  @Test
-  fun `openFile returns null when holder absent`() {
-    CoilArtworkLoaderHolder.get()?.let { CoilArtworkLoaderHolder.clearIf(it) }
-    val token = ArtworkUris.tokenFor("https://cdn/a.png")
-    registry.register(token, ResolvedArtwork("https://cdn/a.png", null, false))
-    assertNull(provider.openFile(uri(token), "r"))
-  }
-
-  // Fix 2: artwork dir must not grow beyond MAX_CACHE_FILES after producing many distinct tokens.
-  // We override the cap to 5 so the test stays fast (rather than producing 512+ real files).
-  @Test
-  fun `openFile prunes cache to MAX_CACHE_FILES after producing excess entries`() {
-    val testCap = 5
-    ArtworkContentProvider.maxCacheFilesOverride = testCap
-    try {
-      val context = RuntimeEnvironment.getApplication()
-      val artworkDir = File(context.cacheDir, ArtworkContentProvider.ARTWORK_SUBDIR)
-      val produce = testCap + 3 // 8 entries total; should be pruned back to 5
-      repeat(produce) { i ->
-        val url = "https://cdn/prune-$i.png"
-        val token = ArtworkUris.tokenFor(url)
-        registry.register(token, ResolvedArtwork(url, null, isSvg = false))
-        provider.openFile(uri(token), "r")
-      }
-      val pngCount = artworkDir.listFiles { f -> f.isFile && f.name.endsWith(".png") }?.size ?: 0
-      assertTrue(
-        "Expected at most $testCap .png files after producing $produce; got $pngCount",
-        pngCount <= testCap,
-      )
-    } finally {
-      ArtworkContentProvider.maxCacheFilesOverride = null
-    }
-  }
-
-  // Prove D-fix: two openFile calls for the same token → loadCount == 1.
-  // The second call is served from the on-disk file without re-decoding.
-  @Test
-  fun `openFile serves second request from disk cache without re-decoding`() {
-    var loadCount = 0
-    val context = RuntimeEnvironment.getApplication()
-    val fakeBitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888)
-    val countingLoader =
-      CoilArtworkLoader(context, FakeImageLoader(context, fakeBitmap) { loadCount++ })
-    CoilArtworkLoaderHolder.set(
-      ArtworkProviderDeps(countingLoader, registry, CoroutineScope(Dispatchers.IO))
-    )
-
-    val token = ArtworkUris.tokenFor("https://cdn/b.png")
-    registry.register(token, ResolvedArtwork("https://cdn/b.png", null, isSvg = false))
-
-    // First call — decode + write to disk.
-    val pfd1 = provider.openFile(uri(token), "r")
-    assertNotNull(pfd1)
-    val bytes1 = java.io.FileInputStream(pfd1!!.fileDescriptor).readBytes()
-    assertNotNull(BitmapFactory.decodeByteArray(bytes1, 0, bytes1.size))
-
-    // Second call — must come from disk, no second decode.
-    val pfd2 = provider.openFile(uri(token), "r")
-    assertNotNull(pfd2)
-    val bytes2 = java.io.FileInputStream(pfd2!!.fileDescriptor).readBytes()
-    assertNotNull(BitmapFactory.decodeByteArray(bytes2, 0, bytes2.size))
-
-    assertEquals(
-      "Expected exactly one decode; second call should be served from disk",
-      1,
-      loadCount,
-    )
-  }
-}