@onekeyfe/react-native-image 3.0.105 → 3.0.106

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyBlockieAvatarLoaderTest.kt

@@ -0,0 +1,327 @@
+package com.margelo.nitro.onekeyimage
+
+import androidx.core.util.Pools
+import com.bumptech.glide.Priority
+import com.bumptech.glide.disklrucache.DiskLruCache
+import com.bumptech.glide.load.DataSource
+import com.bumptech.glide.load.EncodeStrategy
+import com.bumptech.glide.load.Options
+import com.bumptech.glide.load.data.DataFetcher
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.bumptech.glide.load.model.MultiModelLoaderFactory
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.IOException
+import java.io.File
+import java.nio.file.Files
+import java.nio.ByteBuffer
+import java.security.MessageDigest
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+
+class OneKeyBlockieAvatarLoaderTest {
+  private val uri = "onekey-avatar://blockie/v1/0x1234"
+
+  private class Callback : DataFetcher.DataCallback<ByteBuffer> {
+    var data: ByteBuffer? = null
+    var error: Exception? = null
+    override fun onDataReady(data: ByteBuffer?) { this.data = data }
+    override fun onLoadFailed(error: Exception) { this.error = error }
+  }
+
+  @Test
+  fun memoryDiskAvatarRequestsCacheTheOriginalLocalPngAcrossSizes() {
+    val strategy = oneKeyImageMemoryDiskStrategy(uri)
+    assertTrue(strategy.isDataCacheable(DataSource.LOCAL))
+    assertTrue(strategy.decodeCachedData())
+    assertFalse(strategy.decodeCachedResource())
+    assertFalse(strategy.isResourceCacheable(false, DataSource.LOCAL, EncodeStrategy.TRANSFORMED))
+    assertFalse(strategy.isDataCacheable(DataSource.DATA_DISK_CACHE))
+    assertFalse(DiskCacheStrategy.ALL.isDataCacheable(DataSource.LOCAL))
+    assertEquals(DiskCacheStrategy.AUTOMATIC, oneKeyImageMemoryDiskStrategy("https://example.com/image.png"))
+    assertEquals(DiskCacheStrategy.AUTOMATIC, oneKeyImageMemoryDiskStrategy("data:image/png;base64,AA=="))
+    assertFalse(DiskCacheStrategy.AUTOMATIC.isDataCacheable(DataSource.LOCAL))
+  }
+
+  @Test
+  fun originalPngCacheKeyIsStableAcrossRequestedDecodeDimensions() {
+    val factory = MultiModelLoaderFactory(Pools.SynchronizedPool<List<Throwable>>(1))
+    val loader = OneKeyBlockieAvatarLoaderFactory().build(factory)
+    val first = loader.buildLoadData(OneKeyBlockieAvatarModel(uri), 96, 96, Options())!!
+    val second = loader.buildLoadData(OneKeyBlockieAvatarModel(uri), 128, 128, Options())!!
+    val other = loader.buildLoadData(OneKeyBlockieAvatarModel(uri + "0"), 96, 96, Options())!!
+    assertEquals(first.sourceKey, second.sourceKey)
+    assertNotEquals(first.sourceKey, other.sourceKey)
+    val firstDigest = MessageDigest.getInstance("SHA-256").also(first.sourceKey::updateDiskCacheKey).digest()
+    val secondDigest = MessageDigest.getInstance("SHA-256").also(second.sourceKey::updateDiskCacheKey).digest()
+    assertArrayEquals(firstDigest, secondDigest)
+  }
+
+  private fun cacheFetcher(file: File): DataFetcher<ByteBuffer> {
+    val factory = MultiModelLoaderFactory(Pools.SynchronizedPool<List<Throwable>>(1))
+    val loader = OneKeyAvatarCacheFileLoaderFactory().build(factory)
+    return loader.buildLoadData(file, 96, 96, Options().set(oneKeyAvatarCacheFileOption, true))!!.fetcher
+  }
+
+  @Test
+  fun cacheValidationIsNotRegisteredForOrdinaryImageRequests() {
+    val factory = MultiModelLoaderFactory(Pools.SynchronizedPool<List<Throwable>>(1))
+    val loader = OneKeyAvatarCacheFileLoaderFactory().build(factory)
+    assertNull(loader.buildLoadData(File("ordinary-network-image"), 96, 96, Options()))
+  }
+
+  @Test
+  fun validCachedSourceIsReturnedWithoutRemovingOrRewritingIt() {
+    val directory = Files.createTempDirectory("avatar-cache-valid").toFile()
+    val file = File(directory, "avatar.0")
+    val bytes = OneKeyBlockieAvatar.png(uri)
+    try {
+      file.writeBytes(bytes)
+      val modified = file.lastModified()
+      val fetcher = cacheFetcher(file)
+      val callback = Callback()
+      fetcher.loadData(Priority.NORMAL, callback)
+      fetcher.cleanup()
+      assertNull(callback.error)
+      assertArrayEquals(bytes, callback.data!!.array())
+      assertEquals(modified, file.lastModified())
+      assertArrayEquals(bytes, file.readBytes())
+    } finally {
+      directory.deleteRecursively()
+    }
+  }
+
+  @Test
+  fun corruptEntryRemovalAllowsRealGlideJournalRewriteAndRestartReuse() {
+    val directory = Files.createTempDirectory("avatar-cache-journal").toFile()
+    val bytes = OneKeyBlockieAvatar.png(uri)
+    try {
+      DiskLruCache.open(directory, 1, 1, 1024L * 1024).use { disk ->
+        disk.edit("avatar").also { editor ->
+          editor.getFile(0).writeBytes(bytes.copyOf(bytes.size - 1))
+          editor.commit()
+        }
+        val file = disk.get("avatar")!!.getFile(0)
+        val fetcher = cacheFetcher(file)
+        val callback = Callback()
+        fetcher.loadData(Priority.NORMAL, callback)
+        fetcher.cleanup()
+        assertTrue(callback.error is IOException)
+        assertNull(callback.data)
+        assertFalse(file.exists())
+        // DiskLruCacheWrapper.put uses this same journal lookup before deciding to skip a write.
+        assertNull(disk.get("avatar"))
+        disk.edit("avatar").also { editor ->
+          editor.getFile(0).writeBytes(bytes)
+          editor.commit()
+        }
+        assertArrayEquals(bytes, disk.get("avatar")!!.getFile(0).readBytes())
+      }
+      DiskLruCache.open(directory, 1, 1, 1024L * 1024).use { reopened ->
+        val fetcher = cacheFetcher(reopened.get("avatar")!!.getFile(0))
+        val callback = Callback()
+        fetcher.loadData(Priority.NORMAL, callback)
+        fetcher.cleanup()
+        assertNull(callback.error)
+        assertArrayEquals(bytes, callback.data!!.array())
+      }
+    } finally {
+      directory.deleteRecursively()
+    }
+  }
+
+  @Test
+  fun oversizedCacheIsRejectedAndRemovedBeforeUnboundedRead() {
+    val directory = Files.createTempDirectory("avatar-cache-large").toFile()
+    val file = File(directory, "avatar.0")
+    try {
+      file.writeBytes(ByteArray(OneKeyBlockieAvatar.MAX_PNG_BYTES + 1))
+      val fetcher = cacheFetcher(file)
+      val callback = Callback()
+      fetcher.loadData(Priority.NORMAL, callback)
+      fetcher.cleanup()
+      assertTrue(callback.error is IOException)
+      assertFalse(file.exists())
+    } finally {
+      directory.deleteRecursively()
+    }
+  }
+
+  @Test
+  fun cancelledCacheReadDoesNotDeleteTheFileOrCallBack() {
+    val directory = Files.createTempDirectory("avatar-cache-cancel").toFile()
+    val file = File(directory, "avatar.0")
+    try {
+      file.writeBytes(byteArrayOf(1, 2, 3))
+      val fetcher = cacheFetcher(file)
+      val callback = Callback()
+      fetcher.cancel()
+      fetcher.loadData(Priority.NORMAL, callback)
+      fetcher.cleanup()
+      assertNull(callback.data)
+      assertNull(callback.error)
+      assertTrue(file.exists())
+    } finally {
+      directory.deleteRecursively()
+    }
+  }
+
+  @Test
+  fun modelDispatchDoesNotDecodeTheUriOrParseHeadersOnMain() {
+    val model = OneKeyImageModel.build("onekey-avatar://blockie/v1/%INVALID", "invalid JSON")
+    assertEquals(OneKeyBlockieAvatarModel("onekey-avatar://blockie/v1/%INVALID"), model)
+  }
+
+  @Test
+  fun defaultFetcherGeneratesAValidatedPngAndReportsLocalData() {
+    val fetcher = OneKeyBlockieAvatarFetcher(uri)
+    val callback = Callback()
+    try {
+      fetcher.loadData(Priority.NORMAL, callback)
+      assertNull(callback.error)
+      assertEquals(DataSource.LOCAL, fetcher.dataSource)
+      assertArrayEquals(OneKeyBlockieAvatar.png(uri), callback.data!!.array())
+    } finally {
+      fetcher.cleanup()
+    }
+  }
+
+  @Test
+  fun malformedUriReportsFailureWithoutReturningImageData() {
+    val fetcher = OneKeyBlockieAvatarFetcher("onekey-avatar://blockie/v2/seed")
+    val callback = Callback()
+    try {
+      fetcher.loadData(Priority.NORMAL, callback)
+      assertNull(callback.data)
+      assertTrue(callback.error is IllegalArgumentException)
+    } finally {
+      fetcher.cleanup()
+    }
+  }
+
+  @Test
+  fun cancelledBeforeLoadingDoesNotGenerateOrCallBack() {
+    val generated = AtomicInteger()
+    val fetcher = OneKeyBlockieAvatarFetcher(uri, OneKeyAvatarInFlight { _, _ ->
+      generated.incrementAndGet()
+      byteArrayOf(1)
+    })
+    val callback = Callback()
+    fetcher.cancel()
+    fetcher.loadData(Priority.NORMAL, callback)
+    fetcher.cleanup()
+    assertEquals(0, generated.get())
+    assertNull(callback.data)
+    assertNull(callback.error)
+  }
+
+  @Test
+  fun cancellationSuppressesLateCallbacksAndReleasesTheWorkForAFreshRequest() {
+    val started = CountDownLatch(1)
+    val complete = CountDownLatch(1)
+    val generated = AtomicInteger()
+    val requests = OneKeyAvatarInFlight { _, cancelled ->
+      if (generated.incrementAndGet() == 1) {
+        started.countDown()
+        check(complete.await(3, TimeUnit.SECONDS))
+        assertTrue(cancelled())
+      }
+      byteArrayOf(1)
+    }
+    val fetcher = OneKeyBlockieAvatarFetcher(uri, requests)
+    val callback = Callback()
+    val executor = Executors.newSingleThreadExecutor()
+    try {
+      val loaded = executor.submit { fetcher.loadData(Priority.NORMAL, callback) }
+      assertTrue(started.await(3, TimeUnit.SECONDS))
+      fetcher.cancel()
+      fetcher.cleanup()
+      complete.countDown()
+      loaded.get(3, TimeUnit.SECONDS)
+      assertNull(callback.data)
+      assertNull(callback.error)
+      val fresh = OneKeyBlockieAvatarFetcher(uri, requests)
+      val next = Callback()
+      fresh.loadData(Priority.NORMAL, next)
+      fresh.cleanup()
+      assertArrayEquals(byteArrayOf(1), next.data!!.array())
+      assertEquals(2, generated.get())
+    } finally {
+      fetcher.cleanup()
+      complete.countDown()
+      executor.shutdownNow()
+    }
+  }
+
+  @Test
+  fun cancellationNeverWaitsForAGlideCallbackHoldingItsOwnLock() {
+    val callbackStarted = CountDownLatch(1)
+    val callbackComplete = CountDownLatch(1)
+    val fetcher = OneKeyBlockieAvatarFetcher(uri, OneKeyAvatarInFlight { _, _ -> byteArrayOf(1) })
+    val executor = Executors.newFixedThreadPool(2)
+    val callback = object : DataFetcher.DataCallback<ByteBuffer> {
+      override fun onDataReady(data: ByteBuffer?) {
+        callbackStarted.countDown()
+        check(callbackComplete.await(3, TimeUnit.SECONDS))
+      }
+      override fun onLoadFailed(error: Exception) { throw error }
+    }
+    try {
+      val loaded = executor.submit { fetcher.loadData(Priority.NORMAL, callback) }
+      assertTrue(callbackStarted.await(3, TimeUnit.SECONDS))
+      executor.submit { fetcher.cancel() }.get(1, TimeUnit.SECONDS)
+      callbackComplete.countDown()
+      loaded.get(3, TimeUnit.SECONDS)
+    } finally {
+      callbackComplete.countDown()
+      fetcher.cleanup()
+      executor.shutdownNow()
+    }
+  }
+
+  @Test
+  fun glideCallbackFailureIsNotReportedAsASecondGenerationFailure() {
+    val failures = AtomicInteger()
+    val expected = IllegalStateException("Synthetic callback failure")
+    val fetcher = OneKeyBlockieAvatarFetcher(uri, OneKeyAvatarInFlight { _, _ -> byteArrayOf(1) })
+    val callback = object : DataFetcher.DataCallback<ByteBuffer> {
+      override fun onDataReady(data: ByteBuffer?) { throw expected }
+      override fun onLoadFailed(error: Exception) { failures.incrementAndGet() }
+    }
+    try {
+      fetcher.loadData(Priority.NORMAL, callback)
+      org.junit.Assert.fail("Callback exception must propagate")
+    } catch (error: IllegalStateException) {
+      assertEquals(expected, error)
+      assertEquals(0, failures.get())
+    } finally {
+      fetcher.cleanup()
+    }
+  }
+
+  @Test
+  fun failedGenerationIsReleasedSoRetryCanSucceed() {
+    val generated = AtomicInteger()
+    val requests = OneKeyAvatarInFlight { _, _ ->
+      if (generated.incrementAndGet() == 1) throw IOException("Synthetic generation failure")
+      byteArrayOf(1)
+    }
+    val failed = OneKeyBlockieAvatarFetcher(uri, requests)
+    val first = Callback()
+    failed.loadData(Priority.NORMAL, first)
+    failed.cleanup()
+    assertTrue(first.error is IOException)
+    val retried = OneKeyBlockieAvatarFetcher(uri, requests)
+    val second = Callback()
+    retried.loadData(Priority.NORMAL, second)
+    retried.cleanup()
+    assertArrayEquals(byteArrayOf(1), second.data!!.array())
+  }
+}

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyBlockieAvatarTest.kt

@@ -0,0 +1,214 @@
+package com.margelo.nitro.onekeyimage
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Test
+import java.io.ByteArrayOutputStream
+import java.io.DataOutputStream
+import java.nio.ByteBuffer
+import java.util.zip.CRC32
+import java.util.zip.DeflaterOutputStream
+import java.util.concurrent.CancellationException
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+
+class OneKeyBlockieAvatarTest {
+  @Test
+  fun percentDecodePreservesJavaScriptNormalizedUtf16WithoutRecasing() {
+    assertEquals("i\u0307中🙂/#+", OneKeyBlockieAvatar.decodeSeed(
+      "onekey-avatar://blockie/v1/i%CC%87%E4%B8%AD%F0%9F%99%82%2F%23%2B",
+    ))
+    assertEquals("İ", OneKeyBlockieAvatar.decodeSeed("onekey-avatar://blockie/v1/%C4%B0"))
+    assertEquals("\u0000", OneKeyBlockieAvatar.decodeSeed("onekey-avatar://blockie/v1/%00"))
+  }
+
+  @Test
+  fun invalidProtocolPercentEncodingAndUtf8AreRejected() {
+    listOf(
+      "onekey-avatar://blockie/v2/seed", "onekey-avatar://blockie/v1/",
+      "onekey-avatar://blockie/v1/%", "onekey-avatar://blockie/v1/%GG",
+      "onekey-avatar://blockie/v1/%C0%AF", "onekey-avatar://blockie/v1/%ED%A0%80",
+      "onekey-avatar://blockie/v1/seed?query", "onekey-avatar://blockie/v1/a/b",
+      "onekey-avatar://blockie/v1/a+b", "onekey-avatar://blockie/v1/中",
+    ).forEach { uri ->
+      try {
+        OneKeyBlockieAvatar.decodeSeed(uri)
+        fail("Invalid avatar URI was accepted")
+      } catch (_: Exception) { }
+    }
+  }
+
+  @Test
+  fun generationIsDeterministicAndEmits128pxIndexedPng() {
+    val uri = "onekey-avatar://blockie/v1/0x1234"
+    val first = OneKeyBlockieAvatar.png(uri)
+    assertArrayEquals(first, OneKeyBlockieAvatar.png(uri))
+    assertArrayEquals(byteArrayOf(-119, 80, 78, 71, 13, 10, 26, 10), first.copyOfRange(0, 8))
+    assertArrayEquals(byteArrayOf(0, 0, 0, -128, 0, 0, 0, -128), first.copyOfRange(16, 24))
+    assertTrue(first.size < 1024)
+  }
+
+  @Test(expected = CancellationException::class)
+  fun cancellationStopsBeforeGeneration() {
+    OneKeyBlockieAvatar.png("onekey-avatar://blockie/v1/seed") { true }
+  }
+
+  @Test(expected = CancellationException::class)
+  fun cancellationAlsoStopsLargeSeedDecoding() {
+    val checks = AtomicInteger()
+    OneKeyBlockieAvatar.png("onekey-avatar://blockie/v1/" + "a".repeat(8192)) {
+      checks.incrementAndGet() > 3
+    }
+  }
+
+  private fun replaceChunk(png: ByteArray, type: String, data: ByteArray): ByteArray {
+    val input = ByteBuffer.wrap(png)
+    input.position(8)
+    while (input.hasRemaining()) {
+      val start = input.position()
+      val length = input.int
+      val chunkType = ByteArray(4).also(input::get).toString(Charsets.US_ASCII)
+      val end = input.position() + length + 4
+      if (chunkType == type) {
+        val chunk = ByteArrayOutputStream()
+        DataOutputStream(chunk).use {
+          val name = type.toByteArray(Charsets.US_ASCII)
+          it.writeInt(data.size)
+          it.write(name)
+          it.write(data)
+          it.writeInt(CRC32().apply { update(name); update(data) }.value.toInt())
+        }
+        return png.copyOfRange(0, start) + chunk.toByteArray() + png.copyOfRange(end, png.size)
+      }
+      input.position(end)
+    }
+    throw IllegalArgumentException("Test PNG chunk missing")
+  }
+
+  private fun compressedPixels(size: Int, invalidFilter: Boolean = false): ByteArray {
+    val result = ByteArrayOutputStream()
+    DeflaterOutputStream(result).use { output ->
+      repeat(size) { index -> output.write(if (invalidFilter && index == 0) 1 else 0) }
+    }
+    return result.toByteArray()
+  }
+
+  @Test
+  fun completeFixedFormatPngPassesIntegrityValidation() {
+    listOf("seed", "0x1234", "%E4%B8%AD%F0%9F%99%82").forEach {
+      assertTrue(OneKeyBlockieAvatar.isValidPng(OneKeyBlockieAvatar.png(OneKeyBlockieAvatar.URI_PREFIX + it)))
+    }
+  }
+
+  @Test
+  fun corruptedOrTruncatedChunksAndTrailingBytesAreRejected() {
+    val png = OneKeyBlockieAvatar.png(OneKeyBlockieAvatar.URI_PREFIX + "seed")
+    assertFalse(OneKeyBlockieAvatar.isValidPng(png.copyOf(png.size - 1)))
+    assertFalse(OneKeyBlockieAvatar.isValidPng(png + byteArrayOf(0)))
+    assertFalse(OneKeyBlockieAvatar.isValidPng(png.copyOf().also { it[45] = (it[45].toInt() xor 1).toByte() }))
+    assertFalse(OneKeyBlockieAvatar.isValidPng(png.copyOf().also { ByteBuffer.wrap(it).putInt(8, Int.MAX_VALUE) }))
+  }
+
+  @Test
+  fun validCrcCannotHideWrongDimensionsOrMalformedCompressedData() {
+    val png = OneKeyBlockieAvatar.png(OneKeyBlockieAvatar.URI_PREFIX + "seed")
+    val header = png.copyOfRange(16, 29).also { it[3] = 96 }
+    assertFalse(OneKeyBlockieAvatar.isValidPng(replaceChunk(png, "IHDR", header)))
+    assertFalse(OneKeyBlockieAvatar.isValidPng(replaceChunk(png, "IDAT", byteArrayOf(1, 2, 3))))
+    assertFalse(OneKeyBlockieAvatar.isValidPng(replaceChunk(png, "IDAT", compressedPixels(128 * 33 - 1))))
+    assertFalse(OneKeyBlockieAvatar.isValidPng(replaceChunk(png, "IDAT", compressedPixels(128 * 33, true))))
+  }
+
+  @Test
+  fun decompressionIsBoundedEvenWhenEveryChunkCrcIsValid() {
+    val png = OneKeyBlockieAvatar.png(OneKeyBlockieAvatar.URI_PREFIX + "seed")
+    val bomb = replaceChunk(png, "IDAT", compressedPixels(1024 * 1024))
+    assertTrue(bomb.size < OneKeyBlockieAvatar.MAX_PNG_BYTES)
+    assertFalse(OneKeyBlockieAvatar.isValidPng(bomb))
+  }
+
+  @Test(expected = CancellationException::class)
+  fun cancellationStopsCachedPngValidation() {
+    OneKeyBlockieAvatar.isValidPng(OneKeyBlockieAvatar.png(OneKeyBlockieAvatar.URI_PREFIX + "seed")) { true }
+  }
+
+  @Test
+  fun overlappingSizeRequestsShareOneGenerationAndDoNotRetainCompletedImages() {
+    val generated = AtomicInteger()
+    val started = CountDownLatch(1)
+    val complete = CountDownLatch(1)
+    val requests = OneKeyAvatarInFlight { _, _ ->
+      generated.incrementAndGet()
+      started.countDown()
+      check(complete.await(3, TimeUnit.SECONDS))
+      byteArrayOf(1, 2, 3)
+    }
+    val leases = List(8) { requests.acquire("uri") }
+    val executor = Executors.newFixedThreadPool(8)
+    try {
+      val values = leases.map { lease -> executor.submit<ByteArray> { lease.bytes() } }
+      assertTrue(started.await(3, TimeUnit.SECONDS))
+      complete.countDown()
+      values.forEach { assertArrayEquals(byteArrayOf(1, 2, 3), it.get(3, TimeUnit.SECONDS)) }
+      assertEquals(1, generated.get())
+      leases.forEach { it.release() }
+      val fresh = requests.acquire("uri")
+      assertArrayEquals(byteArrayOf(1, 2, 3), fresh.bytes())
+      fresh.release()
+      assertEquals(2, generated.get())
+    } finally {
+      complete.countDown()
+      leases.forEach { it.release() }
+      executor.shutdownNow()
+    }
+  }
+
+  @Test
+  fun cancellingOneConsumerKeepsTheOtherConsumerAlive() {
+    val requests = OneKeyAvatarInFlight { _, cancelled ->
+      assertFalse(cancelled())
+      byteArrayOf(7)
+    }
+    val cancelled = requests.acquire("uri")
+    val active = requests.acquire("uri")
+    cancelled.release()
+    cancelled.release()
+    assertArrayEquals(byteArrayOf(7), active.bytes())
+    active.release()
+  }
+
+  @Test
+  fun cancellingEveryConsumerStopsWorkAndAllowsAFreshRequest() {
+    val started = CountDownLatch(1)
+    val stopped = CountDownLatch(1)
+    val generated = AtomicInteger()
+    val requests = OneKeyAvatarInFlight { _, cancelled ->
+      if (generated.incrementAndGet() == 1) {
+        started.countDown()
+        while (!cancelled()) Thread.yield()
+        stopped.countDown()
+        throw CancellationException("Cancelled")
+      }
+      byteArrayOf(9)
+    }
+    val lease = requests.acquire("uri")
+    val executor = Executors.newSingleThreadExecutor()
+    try {
+      executor.submit { try { lease.bytes() } catch (_: CancellationException) { } }
+      assertTrue(started.await(3, TimeUnit.SECONDS))
+      lease.release()
+      assertTrue(stopped.await(3, TimeUnit.SECONDS))
+      val fresh = requests.acquire("uri")
+      assertArrayEquals(byteArrayOf(9), fresh.bytes())
+      fresh.release()
+    } finally {
+      lease.release()
+      executor.shutdownNow()
+    }
+  }
+}