react-native-audio-browser 0.2.0-next.2 → 0.2.0-next.21

package/ios/Tests/CarPlayArtworkResolverTests.swift

@@ -10,7 +10,7 @@ struct SFSymbolTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "sf:heart.fill",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -22,7 +22,7 @@ struct SFSymbolTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "sf:play.circle?bg=#000&fg=#fff",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 24, targetHeight: 24,
       displayScale: 3.0,
       urlResolver: nil,
@@ -35,7 +35,7 @@ struct SFSymbolTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "sf:music.note",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: { _, _ in
@@ -51,7 +51,7 @@ struct SFSymbolTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: nil,
       artworkSourceUri: "sf:star.fill",
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 20, targetHeight: 20,
       displayScale: 2.0,
       urlResolver: nil,
@@ -68,7 +68,7 @@ struct NoArtworkTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: nil,
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -80,7 +80,7 @@ struct NoArtworkTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: nil,
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: { _, _ in nil },
@@ -97,7 +97,7 @@ struct URLResolutionTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/art.jpg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: false,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: { pixelWidth, pixelHeight in
@@ -121,7 +121,7 @@ struct URLResolutionTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/art.jpg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 24, targetHeight: 24,
       displayScale: 3.0,
       urlResolver: { _, _ in
@@ -140,7 +140,7 @@ struct URLResolutionTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/art.jpg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: { _, _ in nil },
@@ -157,7 +157,7 @@ struct URLResolutionTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/fallback.jpg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: { _, _ in
@@ -180,7 +180,7 @@ struct URLResolutionTests {
     _ = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/art.jpg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 50, targetHeight: 30,
       displayScale: 2.5,
       urlResolver: { w, h in
@@ -202,7 +202,7 @@ struct DirectFallbackTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/artwork.png",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -219,7 +219,7 @@ struct DirectFallbackTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: nil,
       artworkSourceUri: "https://example.com/source.jpg",
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -236,7 +236,7 @@ struct DirectFallbackTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/artwork.jpg",
       artworkSourceUri: "https://example.com/source.jpg",
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -253,7 +253,7 @@ struct DirectFallbackTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -270,7 +270,7 @@ struct SVGDetectionTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/icon.svg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -287,7 +287,7 @@ struct SVGDetectionTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/icon.SVG",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -304,7 +304,7 @@ struct SVGDetectionTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/art.jpg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: { _, _ in
@@ -323,7 +323,7 @@ struct SVGDetectionTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/photo.jpg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -341,11 +341,11 @@ struct SVGDetectionTests {
 
 @Suite("tinting")
 struct TintingTests {
-  @Test func artworkCarPlayTintedTrue_setsShouldTint() async {
+  @Test func stencilTrue_setsShouldTint() async {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/icon.png",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: true,
+      stencil: true,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -358,28 +358,11 @@ struct TintingTests {
     ))
   }
 
-  @Test func artworkCarPlayTintedFalse_doesNotTint() async {
+  @Test func stencilFalse_doesNotTint() async {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/photo.jpg",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/photo.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-
-  @Test func artworkCarPlayTintedNil_defaultsToFalse() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/photo.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
+      stencil: false,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: nil,
@@ -396,7 +379,7 @@ struct TintingTests {
     let action = await CarPlayArtworkResolver.resolve(
       artwork: "https://example.com/icon.png",
       artworkSourceUri: nil,
-      artworkCarPlayTinted: true,
+      stencil: true,
       targetWidth: 40, targetHeight: 40,
       displayScale: 2.0,
       urlResolver: { _, _ in

package/ios/Tests/InertStyleDiagnosticTests.swift

@@ -0,0 +1,200 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+// The dev diagnostic for declarations that can never render (ADR 0011): the
+// recovery for the compile-time invalid-combination errors the block model
+// deliberately gave up. Structural inertness only — a surface that can't draw
+// a property it understands is intended usage, never a finding.
+
+@Suite("InertStyleDiagnostic")
+struct InertStyleDiagnosticTests {
+  private func findings(
+    _ sections: [Section], page: SectionStyle? = nil, path: String = "/home",
+  ) -> [String] {
+    InertStyleDiagnostic.findings(path: path, pageStyle: page, sections: sections)
+  }
+
+  private func playable(_ src: String = "https://s/a.mp3", style: TrackStyle? = nil) -> Track {
+    Track(src: src, title: "T", style: style)
+  }
+
+  private func browsable(_ path: String = "/albums/1", style: TrackStyle? = nil) -> Track {
+    Track(path: path, title: "T", style: style)
+  }
+
+  // MARK: - Container properties
+
+  @Test func gridWrapOnAListSectionIsInert() {
+    let found = findings([Section(title: "Recent", style: SectionStyle(gridWrap: false), children: [])])
+    #expect(found.count == 1)
+    #expect(found[0].contains("section 'Recent'"))
+    #expect(found[0].contains("style.gridWrap"))
+    #expect(found[0].contains("display 'list'"))
+    #expect(found[0].contains("/home"))
+  }
+
+  @Test func gridWrapInAGridIsLive() {
+    let style = SectionStyle(gridWrap: false, display: .grid)
+    #expect(findings([Section(style: style, children: [])]).isEmpty)
+  }
+
+  @Test func aSectionInheritsThePagesGridDisplay() {
+    // `display` resolves by scope override, so the page's grid makes the
+    // section's `gridWrap` live without the section restating it.
+    let found = findings(
+      [Section(style: SectionStyle(gridWrap: false), children: [])],
+      page: SectionStyle(display: .grid),
+    )
+    #expect(found.isEmpty)
+  }
+
+  @Test func gridTileOnAListSectionIsInert() {
+    let found = findings([Section(style: SectionStyle(gridTile: .card), children: [])])
+    #expect(found.count == 1)
+    #expect(found[0].contains("style.gridTile"))
+    #expect(found[0].contains("section #1"))
+  }
+
+  // MARK: - Item properties
+
+  @Test func cardPropertiesNeedTheCardTreatment() {
+    let plainGrid = SectionStyle(display: .grid, cardTint: "#1e3a8a", cardImage: .background)
+    let found = findings([Section(title: "Featured", style: plainGrid, children: [])])
+    #expect(found.count == 2)
+    #expect(found.contains { $0.contains("style.cardTint") })
+    #expect(found.contains { $0.contains("style.cardImage") })
+    #expect(found.allSatisfy { $0.contains("display 'grid', gridTile 'plain'") })
+  }
+
+  @Test func cardPropertiesInACardGridAreLive() {
+    let cards = SectionStyle(gridTile: .card, display: .grid, cardTint: "#1e3a8a", cardImage: .background)
+    #expect(findings([Section(style: cards, children: [])]).isEmpty)
+  }
+
+  @Test func imageShapeNeedsAShapedTile() {
+    let list = SectionStyle(imageShape: .circular)
+    let cards = SectionStyle(gridTile: .card, display: .grid, imageShape: .circular)
+    let condensed = SectionStyle(gridTile: .condensed, display: .grid, imageShape: .circular)
+    #expect(findings([Section(style: list, children: [])]).count == 1)
+    #expect(findings([Section(style: cards, children: [])]).count == 1)
+    // Plain and condensed tiles both take a shape.
+    #expect(findings([Section(style: condensed, children: [])]).isEmpty)
+  }
+
+  @Test func accessorySymbolIsInertOnlyOnCards() {
+    let rows = SectionStyle(accessorySymbol: "lock.fill")
+    let cards = SectionStyle(gridTile: .card, display: .grid, accessorySymbol: "lock.fill")
+    // List rows draw accessories; card elements have no slot for one.
+    #expect(findings([Section(style: rows, children: [])]).isEmpty)
+    let found = findings([Section(style: cards, children: [])])
+    #expect(found.count == 1)
+    #expect(found[0].contains("no accessory slot"))
+  }
+
+  @Test func artworkRenderingIsNeverInert() {
+    let stencilled = SectionStyle(gridTile: .card, display: .grid, artworkRendering: .stencil)
+    #expect(findings([Section(style: stencilled, children: [])]).isEmpty)
+  }
+
+  // MARK: - Track-level declarations
+
+  @Test func trackDeclarationsAreReportedPerSection() {
+    let section = Section(
+      title: "Results", style: SectionStyle(display: .grid),
+      children: [
+        playable(style: TrackStyle(cardTint: "#111")),
+        playable("https://s/b.mp3", style: TrackStyle(cardTint: "#222")),
+        playable("https://s/c.mp3"),
+      ],
+    )
+    let found = findings([section])
+    #expect(found.count == 1)
+    #expect(found[0].contains("2 tracks in section 'Results'"))
+    #expect(found[0].contains("style.cardTint"))
+  }
+
+  @Test func aTracksOwnShapeIsLiveInAPlainGrid() {
+    let section = Section(
+      style: SectionStyle(display: .grid),
+      children: [playable(style: TrackStyle(imageShape: .circular))],
+    )
+    #expect(findings([section]).isEmpty)
+  }
+
+  // MARK: - The page block
+
+  @Test func aPageDeclarationLiveInOneSectionIsNotReported() {
+    // Card tint reaches both sections; one renders cards. Live is live.
+    let found = findings(
+      [
+        Section(style: SectionStyle(gridTile: .card, display: .grid), children: []),
+        Section(style: SectionStyle(display: .grid), children: []),
+      ],
+      page: SectionStyle(cardTint: "#1e3a8a"),
+    )
+    #expect(found.isEmpty)
+  }
+
+  @Test func aPageDeclarationNoSectionRendersIsReportedOnce() {
+    let found = findings(
+      [
+        Section(title: "A", style: SectionStyle(display: .grid), children: []),
+        Section(title: "B", children: []),
+      ],
+      page: SectionStyle(cardTint: "#1e3a8a"),
+    )
+    #expect(found.count == 1)
+    #expect(found[0].contains("the page block"))
+    #expect(found[0].contains("no section that inherits it"))
+  }
+
+  @Test func aSectionOverrideShadowsThePageValue() {
+    // Every section declares its own tint, so the page's is never resolved —
+    // shadowed, not inert; the diagnostic reports what can't render, not what
+    // isn't reached.
+    let found = findings(
+      [Section(style: SectionStyle(gridTile: .card, display: .grid, cardTint: "#000"), children: [])],
+      page: SectionStyle(cardTint: "#1e3a8a"),
+    )
+    #expect(found.isEmpty)
+  }
+
+  @Test func aPageWideGridMakesSectionDeclarationsLive() {
+    let found = findings(
+      [Section(style: SectionStyle(cardTint: "#111"), children: [])],
+      page: SectionStyle(gridTile: .card, display: .grid),
+    )
+    #expect(found.isEmpty)
+  }
+
+  // MARK: - The positional `display`
+
+  @Test func displayOnAPlayableTrackIsInert() {
+    let section = Section(
+      title: "Tracks",
+      children: [
+        playable(style: TrackStyle(display: .grid)),
+        browsable(style: TrackStyle(display: .grid)),
+      ],
+    )
+    let found = findings([section])
+    #expect(found.count == 1)
+    #expect(found[0].contains("1 track in section 'Tracks'"))
+    #expect(found[0].contains("style.display"))
+    #expect(found[0].contains("opens none"))
+  }
+
+  @Test func displayOnASectionOrPageIsNeverInert() {
+    let found = findings(
+      [Section(style: SectionStyle(display: .list), children: [browsable()])],
+      page: SectionStyle(display: .grid),
+    )
+    #expect(found.isEmpty)
+  }
+
+  @Test func anUnstyledPageIsSilent() {
+    #expect(findings([Section(children: [playable(), browsable()])]).isEmpty)
+    #expect(findings([]).isEmpty)
+  }
+}

package/ios/Tests/JsonModelsTests.swift

@@ -40,7 +40,7 @@ struct JsonTrackArtworkTests {
     // The shape that shipped broken: a container decodes its children eagerly,
     // so one unparseable row rejected the whole page rather than losing an image.
     let json = """
-    { "url": "/favorites", "title": "Favorites", "children": [
+    { "path": "/favorites", "title": "Favorites", "children": [
       { "title": "Playlist", "artwork": { "light": "https://e.example/l.png", "dark": "https://e.example/d.png" } }
     ] }
     """.data(using: .utf8)!
@@ -56,3 +56,152 @@ struct JsonTrackArtworkTests {
     }
   }
 }
+
+// MARK: - Style blocks (ADR 0011)
+
+@Suite("JsonTrack.style")
+struct JsonStyleTests {
+  @Test func decodesABlockOntoTrackStyle() throws {
+    let json = Data(
+      """
+      {"title":"X","style":{"display":"grid","artworkRendering":"stencil"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.style?.display == .grid)
+    #expect(track.style?.artworkRendering == .stencil)
+  }
+
+  @Test func decodesABlockOntoSectionStyle() throws {
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","sections":[
+        {"style":{"display":"grid","gridWrap":false},"children":[{"title":"C","src":"s"}]}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    let style = resolved.sections?.first?.style
+    #expect(style?.display == .grid)
+    #expect(style?.gridWrap == false)
+  }
+
+  @Test func staleStringStyleDecodesAsNoDeclaration() throws {
+    // The retired string vocabulary must never kill the page (tolerant
+    // decoding, ADR 0011) — it decodes as an empty block.
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","style":"rail","children":[
+        {"title":"C","src":"s","style":"grid"}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    #expect(resolved.style == nil)
+    #expect(resolved.children?.first?.style == nil)
+  }
+
+  @Test func unknownEnumValuesDecodeAsNoDeclaration() throws {
+    let json = Data(
+      """
+      {"title":"X","style":{"display":"carousel","artworkRendering":"embossed","gridWrap":"yes"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    // All-unknown declarations collapse to "no block" — one shape for "no
+    // declaration" on every platform.
+    #expect(track.style == nil)
+  }
+
+  @Test func decodesDisabled() throws {
+    let json = Data("""
+    {"title":"X","src":"s","disabled":true}
+    """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.disabled == true)
+  }
+
+  @Test func decodesImageShapeAndAccessorySymbol() throws {
+    let json = Data(
+      """
+      {"title":"X","style":{"imageShape":"circular","accessorySymbol":"lock.fill"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.style?.imageShape == .circular)
+    #expect(track.style?.accessorySymbol == "lock.fill")
+  }
+
+  @Test func accessorySymbolNoneIsAValueNotEmptiness() throws {
+    // The inheritance-escape sentinel must survive the wire — collapsing it
+    // to "no declaration" would let the section value flow back in.
+    let json = Data(
+      """
+      {"title":"X","style":{"accessorySymbol":"none"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.style?.accessorySymbol == "none")
+  }
+
+  @Test func unknownImageShapeDecodesAsNoDeclaration() throws {
+    let json = Data(
+      """
+      {"title":"X","style":{"imageShape":"hexagonal"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.style == nil)
+  }
+
+  @Test func decodesTheCardFamily() throws {
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","sections":[
+        {"style":{"display":"grid","gridTile":"card","cardTint":"#1e3a8a","cardImage":"background"},
+         "children":[{"title":"C","src":"s"}]}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    let style = resolved.sections?.first?.style
+    #expect(style?.gridTile == .card)
+    #expect(style?.cardTint == "#1e3a8a")
+    #expect(style?.cardImage == .background)
+  }
+
+  @Test func unknownGridTileDecodesAsNoDeclaration() throws {
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","sections":[
+        {"style":{"gridTile":"hexagon"},"children":[{"title":"C","src":"s"}]}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    #expect(resolved.sections?.first?.style == nil)
+  }
+
+  @Test func styleAndDisabledSurviveThePersistenceRoundTrip() throws {
+    // Restored queues keep their visible fidelity across process death.
+    let original = JsonTrack(
+      title: "X", src: "s",
+      style: JsonStyle(
+        display: "grid", artworkRendering: "stencil",
+        imageShape: "circular", accessorySymbol: "lock.fill",
+      ),
+      disabled: true,
+    )
+    let encoded = try JSONEncoder().encode(original)
+    let decoded = try JSONDecoder().decode(JsonTrack.self, from: encoded)
+    #expect(decoded.style == original.style)
+    #expect(decoded.disabled == true)
+  }
+
+  @Test func liveBlockSnapshotsAllItemProperties() throws {
+    // The persistence snapshot (JsonStyle from a live TrackStyle) must not
+    // drop the newer item properties.
+    let snapshot = JsonStyle(
+      TrackStyle(
+        display: nil, artworkRendering: .stencil,
+        imageShape: .circular, accessorySymbol: "none",
+        cardTint: "#1e3a8a", cardImage: .background,
+      ))
+    #expect(snapshot?.artworkRendering == "stencil")
+    #expect(snapshot?.imageShape == "circular")
+    #expect(snapshot?.accessorySymbol == "none")
+    #expect(snapshot?.cardTint == "#1e3a8a")
+    #expect(snapshot?.cardImage == "background")
+  }
+}

package/ios/Tests/LRUCacheTests.swift

@@ -0,0 +1,111 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("LRUCache")
+struct LRUCacheTests {
+  /// A class so the tests can observe release through a weak reference.
+  private final class Box {
+    let id: Int
+    init(_ id: Int) { self.id = id }
+  }
+
+  @Test func evictsTheLeastRecentlyUsed() {
+    let cache = LRUCache<String, Int>(maxSize: 2)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    cache.set("c", value: 3)
+
+    #expect(cache.get("a") == nil)
+    #expect(cache.get("b") == 2)
+    #expect(cache.get("c") == 3)
+    #expect(cache.count == 2)
+  }
+
+  /// A read is a use: it must move the entry off the eviction end.
+  @Test func readingPromotesAnEntry() {
+    let cache = LRUCache<String, Int>(maxSize: 2)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    _ = cache.get("a")
+    cache.set("c", value: 3)
+
+    #expect(cache.get("a") == 1)
+    #expect(cache.get("b") == nil)
+  }
+
+  @Test func removeDropsOnlyItsOwnEntry() {
+    let cache = LRUCache<String, Int>(maxSize: 3)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    cache.set("c", value: 3)
+
+    cache.remove("b")
+
+    #expect(cache.get("b") == nil)
+    #expect(cache.get("a") == 1)
+    #expect(cache.get("c") == 3)
+    #expect(cache.count == 2)
+  }
+
+  /// The nodes form a doubly-linked list. If both directions were strong, adjacent nodes would
+  /// retain each other and clearing would drop only the dictionary and the two ends — the chain,
+  /// and everything it holds, would survive (#96).
+  @Test func clearReleasesEveryNode() {
+    let cache = LRUCache<String, Box>(maxSize: 10)
+    weak var first: Box?
+    weak var middle: Box?
+    weak var last: Box?
+
+    do {
+      let a = Box(1), b = Box(2), c = Box(3)
+      (first, middle, last) = (a, b, c)
+      cache.set("a", value: a)
+      cache.set("b", value: b)
+      cache.set("c", value: c)
+    }
+
+    #expect(first != nil, "the cache should still hold its entries")
+
+    cache.clear()
+
+    #expect(first == nil)
+    #expect(middle == nil)
+    #expect(last == nil)
+    #expect(cache.count == 0)
+  }
+
+  /// Same cycle, reached by dropping the cache itself rather than clearing it.
+  @Test func droppingTheCacheReleasesEveryNode() {
+    weak var first: Box?
+    weak var last: Box?
+
+    do {
+      let cache = LRUCache<String, Box>(maxSize: 10)
+      let a = Box(1), b = Box(2)
+      (first, last) = (a, b)
+      cache.set("a", value: a)
+      cache.set("b", value: b)
+      #expect(first != nil)
+    }
+
+    #expect(first == nil)
+    #expect(last == nil)
+  }
+
+  /// Eviction has always unlinked the node it drops; this pins that down alongside the rest.
+  @Test func evictionReleasesTheEvictedNode() {
+    let cache = LRUCache<String, Box>(maxSize: 1)
+    weak var evicted: Box?
+
+    do {
+      let a = Box(1)
+      evicted = a
+      cache.set("a", value: a)
+      cache.set("b", value: Box(2))
+    }
+
+    #expect(evicted == nil)
+  }
+}